diff --git a/go.mod b/go.mod index 8a9c9a8..892d0f7 100644 --- a/go.mod +++ b/go.mod @@ -11,14 +11,14 @@ require ( github.com/etkecc/go-env v1.2.1 github.com/etkecc/go-fswatcher v1.0.1 github.com/etkecc/go-healthchecks/v2 v2.2.2 - github.com/etkecc/go-kit v1.7.5 - github.com/etkecc/go-linkpearl v0.0.0-20251016112544-0d85fb3bccdc + github.com/etkecc/go-kit v1.7.6 + github.com/etkecc/go-linkpearl v0.0.0-20251209104933-55b9c56572bb github.com/etkecc/go-mxidwc v1.0.1 github.com/etkecc/go-secgen v1.4.0 github.com/etkecc/go-validator/v2 v2.2.6 github.com/fsnotify/fsnotify v1.9.0 github.com/gabriel-vasile/mimetype v1.4.11 - github.com/getsentry/sentry-go v0.36.2 + github.com/getsentry/sentry-go v0.40.0 github.com/jhillyerd/enmime/v2 v2.2.0 github.com/kvannotten/mailstrip v0.0.0-20200711213611-0002f5c0467e github.com/lib/pq v1.10.9 @@ -26,9 +26,9 @@ require ( github.com/raja/argon2pw v1.0.2-0.20210910183755-a391af63bd39 github.com/rs/zerolog v1.34.0 github.com/swaggo/swag v1.16.3 - golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 - maunium.net/go/mautrix v0.25.2 - modernc.org/sqlite v1.40.0 + golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 + maunium.net/go/mautrix v0.26.0 + modernc.org/sqlite v1.40.1 ) require ( @@ -39,6 +39,7 @@ require ( github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 // indirect github.com/buger/jsonparser v1.1.1 // indirect github.com/cention-sany/utf7 v0.0.0-20170124080048-26cad61bd60a // indirect + github.com/clipperhouse/displaywidth v0.6.1 // indirect github.com/clipperhouse/stringish v0.1.1 // indirect github.com/clipperhouse/uax29/v2 v2.3.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect @@ -62,26 +63,25 @@ require ( github.com/ncruces/go-strftime v1.0.0 // 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/olekukonko/tablewriter v1.1.0 // indirect - github.com/petermattis/goid v0.0.0-20250904145737-900bdf8bb490 // indirect + github.com/olekukonko/ll v0.1.3 // indirect + github.com/olekukonko/tablewriter v1.1.2 // indirect + github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a // indirect github.com/pkg/errors v0.9.1 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect - github.com/rivo/uniseg v0.4.7 // indirect github.com/ssor/bom v0.0.0-20170718123548-6386211fdfcf // indirect github.com/tidwall/gjson v1.18.0 // indirect github.com/tidwall/match v1.2.0 // indirect github.com/tidwall/pretty v1.2.1 // indirect github.com/tidwall/sjson v1.2.5 // indirect github.com/yuin/goldmark v1.7.13 // indirect - go.mau.fi/util v0.9.2 // indirect - golang.org/x/crypto v0.43.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 - golang.org/x/tools v0.38.0 // indirect + go.mau.fi/util v0.9.3 // indirect + golang.org/x/crypto v0.46.0 // indirect + golang.org/x/net v0.48.0 // indirect + golang.org/x/sys v0.39.0 // indirect + golang.org/x/text v0.32.0 // indirect + golang.org/x/tools v0.39.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect - modernc.org/libc v1.66.10 // indirect + modernc.org/libc v1.67.1 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect ) diff --git a/go.sum b/go.sum index 9e7aa3f..8d68c1c 100644 --- a/go.sum +++ b/go.sum @@ -16,6 +16,8 @@ github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMU github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0= github.com/cention-sany/utf7 v0.0.0-20170124080048-26cad61bd60a h1:MISbI8sU/PSK/ztvmWKFcI7UGb5/HQT7B+i3a2myKgI= github.com/cention-sany/utf7 v0.0.0-20170124080048-26cad61bd60a/go.mod h1:2GxOXOlEPAMFPfp014mK1SWq8G8BN8o7/dfYqJrVGn8= +github.com/clipperhouse/displaywidth v0.6.1 h1:/zMlAezfDzT2xy6acHBzwIfyu2ic0hgkT83UX5EY2gY= +github.com/clipperhouse/displaywidth v0.6.1/go.mod h1:R+kHuzaYWFkTm7xoMmK1lFydbci4X2CicfbGstSGg0o= 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= @@ -41,10 +43,10 @@ github.com/etkecc/go-fswatcher v1.0.1 h1:n9hqtjzTS3ETb9hcZe1EqYA1lkkhlzZlztu3hXw github.com/etkecc/go-fswatcher v1.0.1/go.mod h1:O5TODJ9z6Qb7X+snqHbB+F0Pah6G497Wdg0SFE/UYpE= github.com/etkecc/go-healthchecks/v2 v2.2.2 h1:YV7e+Ga8JY3aZX4Qf6Q1Ca+DnqbT5Drjli3PufB4J1g= github.com/etkecc/go-healthchecks/v2 v2.2.2/go.mod h1:IowWGN4F6By6z0eh63+639OscylgtdvT9ITjfN6hnZA= -github.com/etkecc/go-kit v1.7.5 h1:DbHTbJ69Jnt2d8mjOyKA9f2ARxvi8xgnYgVMlMZd3gI= -github.com/etkecc/go-kit v1.7.5/go.mod h1:ZFeQrvlMIV6OeZ4XJ090kkyNYRRN4+5wcg1vjnOKEGI= -github.com/etkecc/go-linkpearl v0.0.0-20251016112544-0d85fb3bccdc h1:jUwnFg8OxXgp6JEmVyuR0sfUqV3pEbnWJqZnrroCM60= -github.com/etkecc/go-linkpearl v0.0.0-20251016112544-0d85fb3bccdc/go.mod h1:bg9M+agdjBrD0nS3uGUh7iP59mwlVZMw2ah+z3JzNoY= +github.com/etkecc/go-kit v1.7.6 h1:BruKhh6FDfeGe+pBGEBPeIJZTKEXFQxBUfExmePS3h8= +github.com/etkecc/go-kit v1.7.6/go.mod h1:ZFeQrvlMIV6OeZ4XJ090kkyNYRRN4+5wcg1vjnOKEGI= +github.com/etkecc/go-linkpearl v0.0.0-20251209104933-55b9c56572bb h1:jGNx9yUaxC0xfamMOzgmMY3bq5PEDOB5wXmAtZcDpRg= +github.com/etkecc/go-linkpearl v0.0.0-20251209104933-55b9c56572bb/go.mod h1:XLjaRo8Bfk6iiQ+//eCFTw6LViBt4rB9SUBwEggGd/U= github.com/etkecc/go-mxidwc v1.0.1 h1:t4Kq3FxSlQjt1i7RpzE5q3cOWjJ0vrTzzGZRSpgh8mg= github.com/etkecc/go-mxidwc v1.0.1/go.mod h1:WFlntcH4mdual/gNi6X7a6rSJERNuLjdrwM3K/tucQA= github.com/etkecc/go-secgen v1.4.0 h1:PapLpen3aIqG2LDu+U6KWDb4SMW2UGuvetpJjd86yUc= @@ -59,8 +61,8 @@ github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= github.com/gabriel-vasile/mimetype v1.4.11 h1:AQvxbp830wPhHTqc1u7nzoLT+ZFxGY7emj5DR5DYFik= github.com/gabriel-vasile/mimetype v1.4.11/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s= -github.com/getsentry/sentry-go v0.36.2 h1:uhuxRPTrUy0dnSzTd0LrYXlBYygLkKY0hhlG5LXarzM= -github.com/getsentry/sentry-go v0.36.2/go.mod h1:p5Im24mJBeruET8Q4bbcMfCQ+F+Iadc4L48tB1apo2c= +github.com/getsentry/sentry-go v0.40.0 h1:VTJMN9zbTvqDqPwheRVLcp0qcUcM+8eFivvGocAaSbo= +github.com/getsentry/sentry-go v0.40.0/go.mod h1:eRXCoh3uvmjQLY6qu63BjUZnaBu5L5WhMV1RwYO8W5s= github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA= github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= @@ -130,12 +132,12 @@ github.com/olekukonko/cat v0.0.0-20250911104152-50322a0618f6 h1:zrbMGy9YXpIeTnGj 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/petermattis/goid v0.0.0-20250904145737-900bdf8bb490 h1:QTvNkZ5ylY0PGgA+Lih+GdboMLY/G9SEGLMEGVjTVA4= -github.com/petermattis/goid v0.0.0-20250904145737-900bdf8bb490/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= +github.com/olekukonko/ll v0.1.3 h1:sV2jrhQGq5B3W0nENUISCR6azIPf7UBUpVq0x/y70Fg= +github.com/olekukonko/ll v0.1.3/go.mod h1:b52bVQRRPObe+yyBl0TxNfhesL0nedD4Cht0/zx55Ew= +github.com/olekukonko/tablewriter v1.1.2 h1:L2kI1Y5tZBct/O/TyZK1zIE9GlBj/TVs+AY5tZDCDSc= +github.com/olekukonko/tablewriter v1.1.2/go.mod h1:z7SYPugVqGVavWoA2sGsFIoOVNmEHxUAAMrhXONtfkg= +github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a h1:VweslR2akb/ARhXfqSfRbj1vpWwYXf3eeAUyw/ndms0= +github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= @@ -146,8 +148,6 @@ github.com/raja/argon2pw v1.0.2-0.20210910183755-a391af63bd39 h1:2by0+lF6NfaNWhl github.com/raja/argon2pw v1.0.2-0.20210910183755-a391af63bd39/go.mod h1:idX/fPqwjX31YMTF2iIpEpNApV2YbQhSFr4iIhJaqp4= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= -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.8.0 h1:FCbCCtXNOY3UtUuHUYaghJg4y7Fd14rXifAYUAtL9R8= github.com/rogpeppe/go-internal v1.8.0/go.mod h1:WmiCO8CzOY8rg0OYDC4/i/2WRWAB6poM+XZ2dLUbcbE= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= @@ -175,39 +175,39 @@ github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY= github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28= github.com/yuin/goldmark v1.7.13 h1:GPddIs617DnBLFFVJFgpo1aBfe/4xcvMc3SB5t/D0pA= github.com/yuin/goldmark v1.7.13/go.mod h1:ip/1k0VRfGynBgxOz0yCqHrbZXhcjxyuS66Brc7iBKg= -go.mau.fi/util v0.9.2 h1:+S4Z03iCsGqU2WY8X2gySFsFjaLlUHFRDVCYvVwynKM= -go.mau.fi/util v0.9.2/go.mod h1:055elBBCJSdhRsmub7ci9hXZPgGr1U6dYg44cSgRgoU= +go.mau.fi/util v0.9.3 h1:aqNF8KDIN8bFpFbybSk+mEBil7IHeBwlujfyTnvP0uU= +go.mau.fi/util v0.9.3/go.mod h1:krWWfBM1jWTb5f8NCa2TLqWMQuM81X7TGQjhMjBeXmQ= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= -golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04= -golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0= -golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 h1:mgKeJMpvi0yx/sU5GsxQ7p6s2wtOnGAHZWCHUM4KGzY= -golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546/go.mod h1:j/pmGrbnkbPtQfxEe5D0VQhZC6qKbfKifgD0oM7sR70= -golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA= -golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w= +golang.org/x/crypto v0.46.0 h1:cKRW/pmt1pKAfetfu+RCEvjvZkA9RimPbh7bhFjGVBU= +golang.org/x/crypto v0.46.0/go.mod h1:Evb/oLKmMraqjZ2iQTwDwvCtJkczlDuTmdJXoZVzqU0= +golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 h1:DHNhtq3sNNzrvduZZIiFyXWOL9IWaDPHqTnLJp+rCBY= +golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0= +golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk= +golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc= golang.org/x/net v0.0.0-20180911220305-26e67e76b6c3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20210421230115-4e50805a0758/go.mod h1:72T/g9IO56b78aLF+1Kcs5dz7/ng1VjMUvfKvpfy+jM= -golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4= -golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210= -golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug= -golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +golang.org/x/net v0.48.0 h1:zyQRTTrjc33Lhh0fBgT/H3oZq9WuvRR5gPC70xpDiQU= +golang.org/x/net v0.48.0/go.mod h1:+ndRgGjkh8FGtu1w1FGbEC31if4VrNVMuKTgcAAnQRY= +golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= +golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210420072515-93ed5bcd2bfe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.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/sys v0.39.0 h1:CvCKL8MeisomCi6qNZ+wbb0DN9E5AATixKsvNtMoMFk= +golang.org/x/sys v0.39.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -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/term v0.38.0 h1:PQ5pkm/rLO6HnxFR7N2lJHOZX6Kez5Y1gDSJla6jo7Q= +golang.org/x/term v0.38.0/go.mod h1:bSEAKrOT1W+VSu9TSCMtoGEOUcKxOKgl3LE5QEF/xVg= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -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.32.0 h1:ZD01bjUt1FQ9WJ0ClOL5vxgxOI/sVCNgX1YtKwcY0mU= +golang.org/x/text v0.32.0/go.mod h1:o/rUWzghvpD5TXrTIBuJU77MTaN0ljMWE47kxGJQ7jY= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ= -golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs= +golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ= +golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= @@ -220,20 +220,22 @@ gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -maunium.net/go/mautrix v0.25.2 h1:CUG23zp754yGOTMh9Q4mVSENS9FyweE/G+6ZsPDMCUU= -maunium.net/go/mautrix v0.25.2/go.mod h1:EWgYyp2iFZP7pnSm+rufHlO8YVnA2KnoNBDpwekiAwI= -modernc.org/cc/v4 v4.26.5 h1:xM3bX7Mve6G8K8b+T11ReenJOT+BmVqQj0FY5T4+5Y4= -modernc.org/cc/v4 v4.26.5/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0= -modernc.org/ccgo/v4 v4.28.1 h1:wPKYn5EC/mYTqBO373jKjvX2n+3+aK7+sICCv4Fjy1A= -modernc.org/ccgo/v4 v4.28.1/go.mod h1:uD+4RnfrVgE6ec9NGguUNdhqzNIeeomeXf6CL0GTE5Q= +maunium.net/go/mautrix v0.26.0 h1:valc2VmZF+oIY4bMq4Cd5H9cEKMRe8eP4FM7iiaYLxI= +maunium.net/go/mautrix v0.26.0/go.mod h1:NWMv+243NX/gDrLofJ2nNXJPrG8vzoM+WUCWph85S6Q= +modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis= +modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0= +modernc.org/ccgo/v4 v4.30.1 h1:4r4U1J6Fhj98NKfSjnPUN7Ze2c6MnAdL0hWw6+LrJpc= +modernc.org/ccgo/v4 v4.30.1/go.mod h1:bIOeI1JL54Utlxn+LwrFyjCx2n2RDiYEaJVSrgdrRfM= modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA= modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= +modernc.org/gc/v3 v3.1.1 h1:k8T3gkXWY9sEiytKhcgyiZ2L0DTyCQ/nvX+LoCljoRE= +modernc.org/gc/v3 v3.1.1/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= -modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A= -modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I= +modernc.org/libc v1.67.1 h1:bFaqOaa5/zbWYJo8aW0tXPX21hXsngG2M7mckCnFSVk= +modernc.org/libc v1.67.1/go.mod h1:QvvnnJ5P7aitu0ReNpVIEyesuhmDLQ8kaEoyMjIFZJA= modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= @@ -242,8 +244,8 @@ modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8= modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= -modernc.org/sqlite v1.40.0 h1:bNWEDlYhNPAUdUdBzjAvn8icAs/2gaKlj4vM+tQ6KdQ= -modernc.org/sqlite v1.40.0/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE= +modernc.org/sqlite v1.40.1 h1:VfuXcxcUWWKRBuP8+BR9L7VnmusMgBNNnBYGEe9w/iY= +modernc.org/sqlite v1.40.1/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= diff --git a/vendor/github.com/clipperhouse/displaywidth/.gitignore b/vendor/github.com/clipperhouse/displaywidth/.gitignore new file mode 100644 index 0000000..e43b0f9 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/.gitignore @@ -0,0 +1 @@ +.DS_Store diff --git a/vendor/github.com/clipperhouse/displaywidth/AGENTS.md b/vendor/github.com/clipperhouse/displaywidth/AGENTS.md new file mode 100644 index 0000000..853e291 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/AGENTS.md @@ -0,0 +1,37 @@ +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 to retrieve details, +or post comments. Then, compare the current branch with main. Reviewing a PR +and reviewing a branch are about the same, but the PR may add context. + +Look for bugs. Think like GitHub Copilot or Cursor BugBot. + +Offer to post a brief summary of the review to the PR, via the gh CLI tool. + +## 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 0000000..c97ce3b --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/CHANGELOG.md @@ -0,0 +1,70 @@ +# Changelog + +## [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 +- Added ASCII fast paths + +## [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/rivo/uniseg/LICENSE.txt b/vendor/github.com/clipperhouse/displaywidth/LICENSE similarity index 96% rename from vendor/github.com/rivo/uniseg/LICENSE.txt rename to vendor/github.com/clipperhouse/displaywidth/LICENSE index 5040f1e..4b8064e 100644 --- a/vendor/github.com/rivo/uniseg/LICENSE.txt +++ b/vendor/github.com/clipperhouse/displaywidth/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2019 Oliver Kuederle +Copyright (c) 2025 Matt Sherman 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/clipperhouse/displaywidth/README.md b/vendor/github.com/clipperhouse/displaywidth/README.md new file mode 100644 index 0000000..e9a513c --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/README.md @@ -0,0 +1,165 @@ +# 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 + +There is one option, `displaywidth.Options.EastAsianWidth`, which 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. +You might do something like: + +```go +var width displaywidth.Options // zero value is default + +func init() { + if os.Getenv("EAST_ASIAN_WIDTH") == "true" { + width = displaywidth.Options{EastAsianWidth: true} + } + // or check locale, or any other logic you want +} + +// use it in your logic +func myApp() { + fmt.Println(width.String("Hello, 世界!")) +} +``` + +## 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). We are keeping +an eye on [emerging standards](https://www.jeffquast.com/post/state-of-terminal-emulation-2025/). + + +`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). + +If you wish to investigate the core logic, see the `lookupProperties` and `width` +functions in [width.go](width.go#L139). The essential trie generation logic is in +`buildPropertyBitmap` in [unicode.go](internal/gen/unicode.go#L316). + + +## 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 10326 ns/op 163.37 MB/s 0 B/op 0 allocs/op +BenchmarkString_Mixed/mattn/go-runewidth-8 14415 ns/op 117.03 MB/s 0 B/op 0 allocs/op +BenchmarkString_Mixed/rivo/uniseg-8 19343 ns/op 87.21 MB/s 0 B/op 0 allocs/op + +BenchmarkString_EastAsian/clipperhouse/displaywidth-8 10561 ns/op 159.74 MB/s 0 B/op 0 allocs/op +BenchmarkString_EastAsian/mattn/go-runewidth-8 23790 ns/op 70.91 MB/s 0 B/op 0 allocs/op +BenchmarkString_EastAsian/rivo/uniseg-8 19322 ns/op 87.31 MB/s 0 B/op 0 allocs/op + +BenchmarkString_ASCII/clipperhouse/displaywidth-8 1033 ns/op 123.88 MB/s 0 B/op 0 allocs/op +BenchmarkString_ASCII/mattn/go-runewidth-8 1168 ns/op 109.59 MB/s 0 B/op 0 allocs/op +BenchmarkString_ASCII/rivo/uniseg-8 1585 ns/op 80.74 MB/s 0 B/op 0 allocs/op + +BenchmarkString_Emoji/clipperhouse/displaywidth-8 3034 ns/op 238.61 MB/s 0 B/op 0 allocs/op +BenchmarkString_Emoji/mattn/go-runewidth-8 4797 ns/op 150.94 MB/s 0 B/op 0 allocs/op +BenchmarkString_Emoji/rivo/uniseg-8 6612 ns/op 109.50 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_Mixed/clipperhouse/displaywidth-8 3343 ns/op 504.67 MB/s 0 B/op 0 allocs/op +BenchmarkRune_Mixed/mattn/go-runewidth-8 5414 ns/op 311.62 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_EastAsian/clipperhouse/displaywidth-8 3393 ns/op 497.17 MB/s 0 B/op 0 allocs/op +BenchmarkRune_EastAsian/mattn/go-runewidth-8 15312 ns/op 110.17 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_ASCII/clipperhouse/displaywidth-8 256.9 ns/op 498.32 MB/s 0 B/op 0 allocs/op +BenchmarkRune_ASCII/mattn/go-runewidth-8 265.7 ns/op 481.75 MB/s 0 B/op 0 allocs/op + +BenchmarkRune_Emoji/clipperhouse/displaywidth-8 1336 ns/op 541.96 MB/s 0 B/op 0 allocs/op +BenchmarkRune_Emoji/mattn/go-runewidth-8 2304 ns/op 314.23 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 0000000..52e1085 --- /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 0000000..673c2aa --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/graphemes.go @@ -0,0 +1,72 @@ +package displaywidth + +import ( + "github.com/clipperhouse/stringish" + "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 stringish.Interface] 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] { + return Graphemes[string]{ + iter: graphemes.FromString(s), + 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] { + return Graphemes[[]byte]{ + iter: graphemes.FromBytes(s), + options: options, + } +} diff --git a/vendor/github.com/clipperhouse/displaywidth/trie.go b/vendor/github.com/clipperhouse/displaywidth/trie.go new file mode 100644 index 0000000..c63ed32 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/trie.go @@ -0,0 +1,1724 @@ +// Code generated by internal/gen/main.go. DO NOT EDIT. + +package displaywidth + +import "github.com/clipperhouse/stringish" + +// 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) + _East_Asian_Wide + // Width depends on EastAsianWidth option + _East_Asian_Ambiguous + // Extended_Pictographic + Emoji_Presentation + _Emoji + // Regional Indicator symbols (used in flag emoji pairs) + _Regional_Indicator +) + +// 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 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: 17792 bytes (17.38 KiB). Checksum: a03a02693a639d4a. +// 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: 248 blocks, 15872 entries, 15872 bytes +// The third block is the zero block. +var stringWidthValues = [15872]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: 0x0004, 0x169b: 0x0004, + 0x16a9: 0x0002, + 0x16aa: 0x0002, + // Block 0x5b, offset 0x16c0 + 0x16e9: 0x0004, + 0x16ea: 0x0004, 0x16eb: 0x0004, 0x16ec: 0x0004, + 0x16f0: 0x0004, 0x16f3: 0x0004, + // 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: 0x0004, 0x187e: 0x0004, + // Block 0x62, offset 0x1880 + 0x1885: 0x0003, + 0x1886: 0x0003, 0x1889: 0x0003, + 0x188e: 0x0003, 0x188f: 0x0003, + 0x1894: 0x0004, 0x1895: 0x0004, + 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: 0x0004, 0x18c9: 0x0004, 0x18ca: 0x0004, 0x18cb: 0x0004, + 0x18cc: 0x0004, 0x18cd: 0x0004, 0x18ce: 0x0004, 0x18cf: 0x0004, 0x18d0: 0x0004, 0x18d1: 0x0004, + 0x18d2: 0x0004, 0x18d3: 0x0004, + 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: 0x0004, + // Block 0x64, offset 0x1900 + 0x190a: 0x0002, 0x190b: 0x0002, + 0x190c: 0x0002, 0x190d: 0x0002, 0x190e: 0x0002, 0x190f: 0x0002, + 0x1913: 0x0004, + 0x191e: 0x0003, 0x191f: 0x0003, 0x1921: 0x0004, + 0x192a: 0x0004, 0x192b: 0x0004, + 0x193d: 0x0004, 0x193e: 0x0004, 0x193f: 0x0003, + // Block 0x65, offset 0x1940 + 0x1944: 0x0004, 0x1945: 0x0004, + 0x1946: 0x0003, 0x1947: 0x0003, 0x1948: 0x0003, 0x1949: 0x0003, 0x194a: 0x0003, 0x194b: 0x0003, + 0x194c: 0x0003, 0x194d: 0x0003, 0x194e: 0x0004, 0x194f: 0x0003, 0x1950: 0x0003, 0x1951: 0x0003, + 0x1952: 0x0003, 0x1953: 0x0003, 0x1954: 0x0004, 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: 0x0004, 0x196b: 0x0003, 0x196c: 0x0003, 0x196d: 0x0003, 0x196e: 0x0003, 0x196f: 0x0003, + 0x1970: 0x0003, 0x1971: 0x0003, 0x1972: 0x0004, 0x1973: 0x0004, 0x1974: 0x0003, 0x1975: 0x0004, + 0x1976: 0x0003, 0x1977: 0x0003, 0x1978: 0x0003, 0x1979: 0x0003, 0x197a: 0x0004, 0x197b: 0x0003, + 0x197c: 0x0003, 0x197d: 0x0004, 0x197e: 0x0003, 0x197f: 0x0003, + // Block 0x66, offset 0x1980 + 0x1985: 0x0004, + 0x198a: 0x0004, 0x198b: 0x0004, + 0x19a8: 0x0004, + 0x19bd: 0x0003, + // Block 0x67, offset 0x19c0 + 0x19cc: 0x0004, 0x19ce: 0x0004, + 0x19d3: 0x0004, 0x19d4: 0x0004, 0x19d5: 0x0004, 0x19d7: 0x0004, + 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: 0x0004, 0x1a16: 0x0004, 0x1a17: 0x0004, + 0x1a30: 0x0004, + 0x1a3f: 0x0004, + // Block 0x69, offset 0x1a40 + 0x1a5b: 0x0004, 0x1a5c: 0x0004, + // Block 0x6a, offset 0x1a80 + 0x1a90: 0x0004, + 0x1a95: 0x0004, 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, + // 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, 0x30d6: 0x0002, 0x30d7: 0x0002, + 0x30d8: 0x0002, 0x30d9: 0x0002, 0x30da: 0x0002, 0x30db: 0x0002, 0x30dc: 0x0002, 0x30dd: 0x0002, + 0x30de: 0x0002, 0x30df: 0x0002, 0x30e0: 0x0002, 0x30e1: 0x0002, 0x30e2: 0x0002, 0x30e3: 0x0002, + 0x30e4: 0x0002, 0x30e5: 0x0002, 0x30e6: 0x0002, 0x30e7: 0x0002, 0x30e8: 0x0002, 0x30e9: 0x0002, + 0x30ea: 0x0002, 0x30eb: 0x0002, 0x30ec: 0x0002, 0x30ed: 0x0002, 0x30ee: 0x0002, 0x30ef: 0x0002, + 0x30f0: 0x0002, 0x30f1: 0x0002, 0x30f2: 0x0002, 0x30f3: 0x0002, 0x30f4: 0x0002, 0x30f5: 0x0002, + 0x30f6: 0x0002, 0x30f7: 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, + 0x313f: 0x0002, + // Block 0xc5, offset 0x3140 + 0x3140: 0x0002, 0x3141: 0x0002, 0x3142: 0x0002, 0x3143: 0x0002, 0x3144: 0x0002, 0x3145: 0x0002, + 0x3146: 0x0002, 0x3147: 0x0002, 0x3148: 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: 0x0004, + // Block 0xda, offset 0x3680 + 0x368f: 0x0004, + // 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: 0x0004, 0x374f: 0x0003, 0x3750: 0x0003, 0x3751: 0x0004, + 0x3752: 0x0004, 0x3753: 0x0004, 0x3754: 0x0004, 0x3755: 0x0004, 0x3756: 0x0004, 0x3757: 0x0004, + 0x3758: 0x0004, 0x3759: 0x0004, 0x375a: 0x0004, 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: 0x0005, 0x37a7: 0x0005, 0x37a8: 0x0005, 0x37a9: 0x0005, + 0x37aa: 0x0005, 0x37ab: 0x0005, 0x37ac: 0x0005, 0x37ad: 0x0005, 0x37ae: 0x0005, 0x37af: 0x0005, + 0x37b0: 0x0005, 0x37b1: 0x0005, 0x37b2: 0x0005, 0x37b3: 0x0005, 0x37b4: 0x0005, 0x37b5: 0x0005, + 0x37b6: 0x0005, 0x37b7: 0x0005, 0x37b8: 0x0005, 0x37b9: 0x0005, 0x37ba: 0x0005, 0x37bb: 0x0005, + 0x37bc: 0x0005, 0x37bd: 0x0005, 0x37be: 0x0005, 0x37bf: 0x0005, + // Block 0xdf, offset 0x37c0 + 0x37c0: 0x0002, 0x37c1: 0x0004, 0x37c2: 0x0002, + 0x37d0: 0x0002, 0x37d1: 0x0002, + 0x37d2: 0x0002, 0x37d3: 0x0002, 0x37d4: 0x0002, 0x37d5: 0x0002, 0x37d6: 0x0002, 0x37d7: 0x0002, + 0x37d8: 0x0002, 0x37d9: 0x0002, 0x37da: 0x0004, 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: 0x0004, + 0x37f0: 0x0002, 0x37f1: 0x0002, 0x37f2: 0x0004, 0x37f3: 0x0004, 0x37f4: 0x0004, 0x37f5: 0x0004, + 0x37f6: 0x0004, 0x37f7: 0x0002, 0x37f8: 0x0004, 0x37f9: 0x0004, 0x37fa: 0x0004, 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: 0x0004, 0x3811: 0x0004, + 0x3820: 0x0002, 0x3821: 0x0002, 0x3822: 0x0002, 0x3823: 0x0002, + 0x3824: 0x0002, 0x3825: 0x0002, + // Block 0xe1, offset 0x3840 + 0x3840: 0x0004, 0x3841: 0x0004, 0x3842: 0x0004, 0x3843: 0x0004, 0x3844: 0x0004, 0x3845: 0x0004, + 0x3846: 0x0004, 0x3847: 0x0004, 0x3848: 0x0004, 0x3849: 0x0004, 0x384a: 0x0004, 0x384b: 0x0004, + 0x384c: 0x0004, 0x384d: 0x0004, 0x384e: 0x0004, 0x384f: 0x0004, 0x3850: 0x0004, 0x3851: 0x0004, + 0x3852: 0x0004, 0x3853: 0x0004, 0x3854: 0x0004, 0x3855: 0x0004, 0x3856: 0x0004, 0x3857: 0x0004, + 0x3858: 0x0004, 0x3859: 0x0004, 0x385a: 0x0004, 0x385b: 0x0004, 0x385c: 0x0004, 0x385d: 0x0004, + 0x385e: 0x0004, 0x385f: 0x0004, 0x3860: 0x0004, + 0x386d: 0x0004, 0x386e: 0x0004, 0x386f: 0x0004, + 0x3870: 0x0004, 0x3871: 0x0004, 0x3872: 0x0004, 0x3873: 0x0004, 0x3874: 0x0004, 0x3875: 0x0004, + 0x3877: 0x0004, 0x3878: 0x0004, 0x3879: 0x0004, 0x387a: 0x0004, 0x387b: 0x0004, + 0x387c: 0x0004, 0x387d: 0x0004, 0x387e: 0x0004, 0x387f: 0x0004, + // Block 0xe2, offset 0x3880 + 0x3880: 0x0004, 0x3881: 0x0004, 0x3882: 0x0004, 0x3883: 0x0004, 0x3884: 0x0004, 0x3885: 0x0004, + 0x3886: 0x0004, 0x3887: 0x0004, 0x3888: 0x0004, 0x3889: 0x0004, 0x388a: 0x0004, 0x388b: 0x0004, + 0x388c: 0x0004, 0x388d: 0x0004, 0x388e: 0x0004, 0x388f: 0x0004, 0x3890: 0x0004, 0x3891: 0x0004, + 0x3892: 0x0004, 0x3893: 0x0004, 0x3894: 0x0004, 0x3895: 0x0004, 0x3896: 0x0004, 0x3897: 0x0004, + 0x3898: 0x0004, 0x3899: 0x0004, 0x389a: 0x0004, 0x389b: 0x0004, 0x389c: 0x0004, 0x389d: 0x0004, + 0x389e: 0x0004, 0x389f: 0x0004, 0x38a0: 0x0004, 0x38a1: 0x0004, 0x38a2: 0x0004, 0x38a3: 0x0004, + 0x38a4: 0x0004, 0x38a5: 0x0004, 0x38a6: 0x0004, 0x38a7: 0x0004, 0x38a8: 0x0004, 0x38a9: 0x0004, + 0x38aa: 0x0004, 0x38ab: 0x0004, 0x38ac: 0x0004, 0x38ad: 0x0004, 0x38ae: 0x0004, 0x38af: 0x0004, + 0x38b0: 0x0004, 0x38b1: 0x0004, 0x38b2: 0x0004, 0x38b3: 0x0004, 0x38b4: 0x0004, 0x38b5: 0x0004, + 0x38b6: 0x0004, 0x38b7: 0x0004, 0x38b8: 0x0004, 0x38b9: 0x0004, 0x38ba: 0x0004, 0x38bb: 0x0004, + 0x38bc: 0x0004, 0x38be: 0x0004, 0x38bf: 0x0004, + // Block 0xe3, offset 0x38c0 + 0x38c0: 0x0004, 0x38c1: 0x0004, 0x38c2: 0x0004, 0x38c3: 0x0004, 0x38c4: 0x0004, 0x38c5: 0x0004, + 0x38c6: 0x0004, 0x38c7: 0x0004, 0x38c8: 0x0004, 0x38c9: 0x0004, 0x38ca: 0x0004, 0x38cb: 0x0004, + 0x38cc: 0x0004, 0x38cd: 0x0004, 0x38ce: 0x0004, 0x38cf: 0x0004, 0x38d0: 0x0004, 0x38d1: 0x0004, + 0x38d2: 0x0004, 0x38d3: 0x0004, + 0x38e0: 0x0004, 0x38e1: 0x0004, 0x38e2: 0x0004, 0x38e3: 0x0004, + 0x38e4: 0x0004, 0x38e5: 0x0004, 0x38e6: 0x0004, 0x38e7: 0x0004, 0x38e8: 0x0004, 0x38e9: 0x0004, + 0x38ea: 0x0004, 0x38eb: 0x0004, 0x38ec: 0x0004, 0x38ed: 0x0004, 0x38ee: 0x0004, 0x38ef: 0x0004, + 0x38f0: 0x0004, 0x38f1: 0x0004, 0x38f2: 0x0004, 0x38f3: 0x0004, 0x38f4: 0x0004, 0x38f5: 0x0004, + 0x38f6: 0x0004, 0x38f7: 0x0004, 0x38f8: 0x0004, 0x38f9: 0x0004, 0x38fa: 0x0004, 0x38fb: 0x0004, + 0x38fc: 0x0004, 0x38fd: 0x0004, 0x38fe: 0x0004, 0x38ff: 0x0004, + // Block 0xe4, offset 0x3900 + 0x3900: 0x0004, 0x3901: 0x0004, 0x3902: 0x0004, 0x3903: 0x0004, 0x3904: 0x0004, 0x3905: 0x0004, + 0x3906: 0x0004, 0x3907: 0x0004, 0x3908: 0x0004, 0x3909: 0x0004, 0x390a: 0x0004, + 0x390f: 0x0004, 0x3910: 0x0004, 0x3911: 0x0004, + 0x3912: 0x0004, 0x3913: 0x0004, + 0x3920: 0x0004, 0x3921: 0x0004, 0x3922: 0x0004, 0x3923: 0x0004, + 0x3924: 0x0004, 0x3925: 0x0004, 0x3926: 0x0004, 0x3927: 0x0004, 0x3928: 0x0004, 0x3929: 0x0004, + 0x392a: 0x0004, 0x392b: 0x0004, 0x392c: 0x0004, 0x392d: 0x0004, 0x392e: 0x0004, 0x392f: 0x0004, + 0x3930: 0x0004, 0x3934: 0x0004, + 0x3938: 0x0004, 0x3939: 0x0004, 0x393a: 0x0004, 0x393b: 0x0002, + 0x393c: 0x0002, 0x393d: 0x0002, 0x393e: 0x0002, 0x393f: 0x0002, + // Block 0xe5, offset 0x3940 + 0x3940: 0x0004, 0x3941: 0x0004, 0x3942: 0x0004, 0x3943: 0x0004, 0x3944: 0x0004, 0x3945: 0x0004, + 0x3946: 0x0004, 0x3947: 0x0004, 0x3948: 0x0004, 0x3949: 0x0004, 0x394a: 0x0004, 0x394b: 0x0004, + 0x394c: 0x0004, 0x394d: 0x0004, 0x394e: 0x0004, 0x394f: 0x0004, 0x3950: 0x0004, 0x3951: 0x0004, + 0x3952: 0x0004, 0x3953: 0x0004, 0x3954: 0x0004, 0x3955: 0x0004, 0x3956: 0x0004, 0x3957: 0x0004, + 0x3958: 0x0004, 0x3959: 0x0004, 0x395a: 0x0004, 0x395b: 0x0004, 0x395c: 0x0004, 0x395d: 0x0004, + 0x395e: 0x0004, 0x395f: 0x0004, 0x3960: 0x0004, 0x3961: 0x0004, 0x3962: 0x0004, 0x3963: 0x0004, + 0x3964: 0x0004, 0x3965: 0x0004, 0x3966: 0x0004, 0x3967: 0x0004, 0x3968: 0x0004, 0x3969: 0x0004, + 0x396a: 0x0004, 0x396b: 0x0004, 0x396c: 0x0004, 0x396d: 0x0004, 0x396e: 0x0004, 0x396f: 0x0004, + 0x3970: 0x0004, 0x3971: 0x0004, 0x3972: 0x0004, 0x3973: 0x0004, 0x3974: 0x0004, 0x3975: 0x0004, + 0x3976: 0x0004, 0x3977: 0x0004, 0x3978: 0x0004, 0x3979: 0x0004, 0x397a: 0x0004, 0x397b: 0x0004, + 0x397c: 0x0004, 0x397d: 0x0004, 0x397e: 0x0004, + // Block 0xe6, offset 0x3980 + 0x3980: 0x0004, 0x3982: 0x0004, 0x3983: 0x0004, 0x3984: 0x0004, 0x3985: 0x0004, + 0x3986: 0x0004, 0x3987: 0x0004, 0x3988: 0x0004, 0x3989: 0x0004, 0x398a: 0x0004, 0x398b: 0x0004, + 0x398c: 0x0004, 0x398d: 0x0004, 0x398e: 0x0004, 0x398f: 0x0004, 0x3990: 0x0004, 0x3991: 0x0004, + 0x3992: 0x0004, 0x3993: 0x0004, 0x3994: 0x0004, 0x3995: 0x0004, 0x3996: 0x0004, 0x3997: 0x0004, + 0x3998: 0x0004, 0x3999: 0x0004, 0x399a: 0x0004, 0x399b: 0x0004, 0x399c: 0x0004, 0x399d: 0x0004, + 0x399e: 0x0004, 0x399f: 0x0004, 0x39a0: 0x0004, 0x39a1: 0x0004, 0x39a2: 0x0004, 0x39a3: 0x0004, + 0x39a4: 0x0004, 0x39a5: 0x0004, 0x39a6: 0x0004, 0x39a7: 0x0004, 0x39a8: 0x0004, 0x39a9: 0x0004, + 0x39aa: 0x0004, 0x39ab: 0x0004, 0x39ac: 0x0004, 0x39ad: 0x0004, 0x39ae: 0x0004, 0x39af: 0x0004, + 0x39b0: 0x0004, 0x39b1: 0x0004, 0x39b2: 0x0004, 0x39b3: 0x0004, 0x39b4: 0x0004, 0x39b5: 0x0004, + 0x39b6: 0x0004, 0x39b7: 0x0004, 0x39b8: 0x0004, 0x39b9: 0x0004, 0x39ba: 0x0004, 0x39bb: 0x0004, + 0x39bc: 0x0004, 0x39bd: 0x0004, 0x39be: 0x0004, 0x39bf: 0x0004, + // Block 0xe7, offset 0x39c0 + 0x39c0: 0x0004, 0x39c1: 0x0004, 0x39c2: 0x0004, 0x39c3: 0x0004, 0x39c4: 0x0004, 0x39c5: 0x0004, + 0x39c6: 0x0004, 0x39c7: 0x0004, 0x39c8: 0x0004, 0x39c9: 0x0004, 0x39ca: 0x0004, 0x39cb: 0x0004, + 0x39cc: 0x0004, 0x39cd: 0x0004, 0x39ce: 0x0004, 0x39cf: 0x0004, 0x39d0: 0x0004, 0x39d1: 0x0004, + 0x39d2: 0x0004, 0x39d3: 0x0004, 0x39d4: 0x0004, 0x39d5: 0x0004, 0x39d6: 0x0004, 0x39d7: 0x0004, + 0x39d8: 0x0004, 0x39d9: 0x0004, 0x39da: 0x0004, 0x39db: 0x0004, 0x39dc: 0x0004, 0x39dd: 0x0004, + 0x39de: 0x0004, 0x39df: 0x0004, 0x39e0: 0x0004, 0x39e1: 0x0004, 0x39e2: 0x0004, 0x39e3: 0x0004, + 0x39e4: 0x0004, 0x39e5: 0x0004, 0x39e6: 0x0004, 0x39e7: 0x0004, 0x39e8: 0x0004, 0x39e9: 0x0004, + 0x39ea: 0x0004, 0x39eb: 0x0004, 0x39ec: 0x0004, 0x39ed: 0x0004, 0x39ee: 0x0004, 0x39ef: 0x0004, + 0x39f0: 0x0004, 0x39f1: 0x0004, 0x39f2: 0x0004, 0x39f3: 0x0004, 0x39f4: 0x0004, 0x39f5: 0x0004, + 0x39f6: 0x0004, 0x39f7: 0x0004, 0x39f8: 0x0004, 0x39f9: 0x0004, 0x39fa: 0x0004, 0x39fb: 0x0004, + 0x39fc: 0x0004, 0x39fd: 0x0004, 0x39fe: 0x0004, 0x39ff: 0x0004, + // Block 0xe8, offset 0x3a00 + 0x3a00: 0x0004, 0x3a01: 0x0004, 0x3a02: 0x0004, 0x3a03: 0x0004, 0x3a04: 0x0004, 0x3a05: 0x0004, + 0x3a06: 0x0004, 0x3a07: 0x0004, 0x3a08: 0x0004, 0x3a09: 0x0004, 0x3a0a: 0x0004, 0x3a0b: 0x0004, + 0x3a0c: 0x0004, 0x3a0d: 0x0004, 0x3a0e: 0x0004, 0x3a0f: 0x0004, 0x3a10: 0x0004, 0x3a11: 0x0004, + 0x3a12: 0x0004, 0x3a13: 0x0004, 0x3a14: 0x0004, 0x3a15: 0x0004, 0x3a16: 0x0004, 0x3a17: 0x0004, + 0x3a18: 0x0004, 0x3a19: 0x0004, 0x3a1a: 0x0004, 0x3a1b: 0x0004, 0x3a1c: 0x0004, 0x3a1d: 0x0004, + 0x3a1e: 0x0004, 0x3a1f: 0x0004, 0x3a20: 0x0004, 0x3a21: 0x0004, 0x3a22: 0x0004, 0x3a23: 0x0004, + 0x3a24: 0x0004, 0x3a25: 0x0004, 0x3a26: 0x0004, 0x3a27: 0x0004, 0x3a28: 0x0004, 0x3a29: 0x0004, + 0x3a2a: 0x0004, 0x3a2b: 0x0004, 0x3a2c: 0x0004, 0x3a2d: 0x0004, 0x3a2e: 0x0004, 0x3a2f: 0x0004, + 0x3a30: 0x0004, 0x3a31: 0x0004, 0x3a32: 0x0004, 0x3a33: 0x0004, 0x3a34: 0x0004, 0x3a35: 0x0004, + 0x3a36: 0x0004, 0x3a37: 0x0004, 0x3a38: 0x0004, 0x3a39: 0x0004, 0x3a3a: 0x0004, 0x3a3b: 0x0004, + 0x3a3c: 0x0004, 0x3a3f: 0x0004, + // Block 0xe9, offset 0x3a40 + 0x3a40: 0x0004, 0x3a41: 0x0004, 0x3a42: 0x0004, 0x3a43: 0x0004, 0x3a44: 0x0004, 0x3a45: 0x0004, + 0x3a46: 0x0004, 0x3a47: 0x0004, 0x3a48: 0x0004, 0x3a49: 0x0004, 0x3a4a: 0x0004, 0x3a4b: 0x0004, + 0x3a4c: 0x0004, 0x3a4d: 0x0004, 0x3a4e: 0x0004, 0x3a4f: 0x0004, 0x3a50: 0x0004, 0x3a51: 0x0004, + 0x3a52: 0x0004, 0x3a53: 0x0004, 0x3a54: 0x0004, 0x3a55: 0x0004, 0x3a56: 0x0004, 0x3a57: 0x0004, + 0x3a58: 0x0004, 0x3a59: 0x0004, 0x3a5a: 0x0004, 0x3a5b: 0x0004, 0x3a5c: 0x0004, 0x3a5d: 0x0004, + 0x3a5e: 0x0004, 0x3a5f: 0x0004, 0x3a60: 0x0004, 0x3a61: 0x0004, 0x3a62: 0x0004, 0x3a63: 0x0004, + 0x3a64: 0x0004, 0x3a65: 0x0004, 0x3a66: 0x0004, 0x3a67: 0x0004, 0x3a68: 0x0004, 0x3a69: 0x0004, + 0x3a6a: 0x0004, 0x3a6b: 0x0004, 0x3a6c: 0x0004, 0x3a6d: 0x0004, 0x3a6e: 0x0004, 0x3a6f: 0x0004, + 0x3a70: 0x0004, 0x3a71: 0x0004, 0x3a72: 0x0004, 0x3a73: 0x0004, 0x3a74: 0x0004, 0x3a75: 0x0004, + 0x3a76: 0x0004, 0x3a77: 0x0004, 0x3a78: 0x0004, 0x3a79: 0x0004, 0x3a7a: 0x0004, 0x3a7b: 0x0004, + 0x3a7c: 0x0004, 0x3a7d: 0x0004, + // Block 0xea, offset 0x3a80 + 0x3a8b: 0x0004, + 0x3a8c: 0x0004, 0x3a8d: 0x0004, 0x3a8e: 0x0004, 0x3a90: 0x0004, 0x3a91: 0x0004, + 0x3a92: 0x0004, 0x3a93: 0x0004, 0x3a94: 0x0004, 0x3a95: 0x0004, 0x3a96: 0x0004, 0x3a97: 0x0004, + 0x3a98: 0x0004, 0x3a99: 0x0004, 0x3a9a: 0x0004, 0x3a9b: 0x0004, 0x3a9c: 0x0004, 0x3a9d: 0x0004, + 0x3a9e: 0x0004, 0x3a9f: 0x0004, 0x3aa0: 0x0004, 0x3aa1: 0x0004, 0x3aa2: 0x0004, 0x3aa3: 0x0004, + 0x3aa4: 0x0004, 0x3aa5: 0x0004, 0x3aa6: 0x0004, 0x3aa7: 0x0004, + 0x3aba: 0x0004, + // Block 0xeb, offset 0x3ac0 + 0x3ad5: 0x0004, 0x3ad6: 0x0004, + 0x3ae4: 0x0004, + // Block 0xec, offset 0x3b00 + 0x3b3b: 0x0004, + 0x3b3c: 0x0004, 0x3b3d: 0x0004, 0x3b3e: 0x0004, 0x3b3f: 0x0004, + // Block 0xed, offset 0x3b40 + 0x3b40: 0x0004, 0x3b41: 0x0004, 0x3b42: 0x0004, 0x3b43: 0x0004, 0x3b44: 0x0004, 0x3b45: 0x0004, + 0x3b46: 0x0004, 0x3b47: 0x0004, 0x3b48: 0x0004, 0x3b49: 0x0004, 0x3b4a: 0x0004, 0x3b4b: 0x0004, + 0x3b4c: 0x0004, 0x3b4d: 0x0004, 0x3b4e: 0x0004, 0x3b4f: 0x0004, + // Block 0xee, offset 0x3b80 + 0x3b80: 0x0004, 0x3b81: 0x0004, 0x3b82: 0x0004, 0x3b83: 0x0004, 0x3b84: 0x0004, 0x3b85: 0x0004, + 0x3b8c: 0x0004, 0x3b90: 0x0004, 0x3b91: 0x0004, + 0x3b92: 0x0004, 0x3b95: 0x0004, 0x3b96: 0x0004, 0x3b97: 0x0004, + 0x3b9c: 0x0004, 0x3b9d: 0x0004, + 0x3b9e: 0x0004, 0x3b9f: 0x0004, + 0x3bab: 0x0004, 0x3bac: 0x0004, + 0x3bb4: 0x0004, 0x3bb5: 0x0004, + 0x3bb6: 0x0004, 0x3bb7: 0x0004, 0x3bb8: 0x0004, 0x3bb9: 0x0004, 0x3bba: 0x0004, 0x3bbb: 0x0004, + 0x3bbc: 0x0004, + // Block 0xef, offset 0x3bc0 + 0x3be0: 0x0004, 0x3be1: 0x0004, 0x3be2: 0x0004, 0x3be3: 0x0004, + 0x3be4: 0x0004, 0x3be5: 0x0004, 0x3be6: 0x0004, 0x3be7: 0x0004, 0x3be8: 0x0004, 0x3be9: 0x0004, + 0x3bea: 0x0004, 0x3beb: 0x0004, + 0x3bf0: 0x0004, + // Block 0xf0, offset 0x3c00 + 0x3c0c: 0x0004, 0x3c0d: 0x0004, 0x3c0e: 0x0004, 0x3c0f: 0x0004, 0x3c10: 0x0004, 0x3c11: 0x0004, + 0x3c12: 0x0004, 0x3c13: 0x0004, 0x3c14: 0x0004, 0x3c15: 0x0004, 0x3c16: 0x0004, 0x3c17: 0x0004, + 0x3c18: 0x0004, 0x3c19: 0x0004, 0x3c1a: 0x0004, 0x3c1b: 0x0004, 0x3c1c: 0x0004, 0x3c1d: 0x0004, + 0x3c1e: 0x0004, 0x3c1f: 0x0004, 0x3c20: 0x0004, 0x3c21: 0x0004, 0x3c22: 0x0004, 0x3c23: 0x0004, + 0x3c24: 0x0004, 0x3c25: 0x0004, 0x3c26: 0x0004, 0x3c27: 0x0004, 0x3c28: 0x0004, 0x3c29: 0x0004, + 0x3c2a: 0x0004, 0x3c2b: 0x0004, 0x3c2c: 0x0004, 0x3c2d: 0x0004, 0x3c2e: 0x0004, 0x3c2f: 0x0004, + 0x3c30: 0x0004, 0x3c31: 0x0004, 0x3c32: 0x0004, 0x3c33: 0x0004, 0x3c34: 0x0004, 0x3c35: 0x0004, + 0x3c36: 0x0004, 0x3c37: 0x0004, 0x3c38: 0x0004, 0x3c39: 0x0004, 0x3c3a: 0x0004, + 0x3c3c: 0x0004, 0x3c3d: 0x0004, 0x3c3e: 0x0004, 0x3c3f: 0x0004, + // Block 0xf1, offset 0x3c40 + 0x3c40: 0x0004, 0x3c41: 0x0004, 0x3c42: 0x0004, 0x3c43: 0x0004, 0x3c44: 0x0004, 0x3c45: 0x0004, + 0x3c47: 0x0004, 0x3c48: 0x0004, 0x3c49: 0x0004, 0x3c4a: 0x0004, 0x3c4b: 0x0004, + 0x3c4c: 0x0004, 0x3c4d: 0x0004, 0x3c4e: 0x0004, 0x3c4f: 0x0004, 0x3c50: 0x0004, 0x3c51: 0x0004, + 0x3c52: 0x0004, 0x3c53: 0x0004, 0x3c54: 0x0004, 0x3c55: 0x0004, 0x3c56: 0x0004, 0x3c57: 0x0004, + 0x3c58: 0x0004, 0x3c59: 0x0004, 0x3c5a: 0x0004, 0x3c5b: 0x0004, 0x3c5c: 0x0004, 0x3c5d: 0x0004, + 0x3c5e: 0x0004, 0x3c5f: 0x0004, 0x3c60: 0x0004, 0x3c61: 0x0004, 0x3c62: 0x0004, 0x3c63: 0x0004, + 0x3c64: 0x0004, 0x3c65: 0x0004, 0x3c66: 0x0004, 0x3c67: 0x0004, 0x3c68: 0x0004, 0x3c69: 0x0004, + 0x3c6a: 0x0004, 0x3c6b: 0x0004, 0x3c6c: 0x0004, 0x3c6d: 0x0004, 0x3c6e: 0x0004, 0x3c6f: 0x0004, + 0x3c70: 0x0004, 0x3c71: 0x0004, 0x3c72: 0x0004, 0x3c73: 0x0004, 0x3c74: 0x0004, 0x3c75: 0x0004, + 0x3c76: 0x0004, 0x3c77: 0x0004, 0x3c78: 0x0004, 0x3c79: 0x0004, 0x3c7a: 0x0004, 0x3c7b: 0x0004, + 0x3c7c: 0x0004, 0x3c7d: 0x0004, 0x3c7e: 0x0004, 0x3c7f: 0x0004, + // Block 0xf2, offset 0x3c80 + 0x3cb0: 0x0004, 0x3cb1: 0x0004, 0x3cb2: 0x0004, 0x3cb3: 0x0004, 0x3cb4: 0x0004, 0x3cb5: 0x0004, + 0x3cb6: 0x0004, 0x3cb7: 0x0004, 0x3cb8: 0x0004, 0x3cb9: 0x0004, 0x3cba: 0x0004, 0x3cbb: 0x0004, + 0x3cbc: 0x0004, + // Block 0xf3, offset 0x3cc0 + 0x3cc0: 0x0004, 0x3cc1: 0x0004, 0x3cc2: 0x0004, 0x3cc3: 0x0004, 0x3cc4: 0x0004, 0x3cc5: 0x0004, + 0x3cc6: 0x0004, 0x3cc7: 0x0004, 0x3cc8: 0x0004, 0x3cc9: 0x0004, + 0x3ccf: 0x0004, 0x3cd0: 0x0004, 0x3cd1: 0x0004, + 0x3cd2: 0x0004, 0x3cd3: 0x0004, 0x3cd4: 0x0004, 0x3cd5: 0x0004, 0x3cd6: 0x0004, 0x3cd7: 0x0004, + 0x3cd8: 0x0004, 0x3cd9: 0x0004, 0x3cda: 0x0004, 0x3cdb: 0x0004, 0x3cdc: 0x0004, 0x3cdd: 0x0004, + 0x3cde: 0x0004, 0x3cdf: 0x0004, 0x3ce0: 0x0004, 0x3ce1: 0x0004, 0x3ce2: 0x0004, 0x3ce3: 0x0004, + 0x3ce4: 0x0004, 0x3ce5: 0x0004, 0x3ce6: 0x0004, 0x3ce7: 0x0004, 0x3ce8: 0x0004, 0x3ce9: 0x0004, + 0x3cea: 0x0004, 0x3ceb: 0x0004, 0x3cec: 0x0004, 0x3ced: 0x0004, 0x3cee: 0x0004, 0x3cef: 0x0004, + 0x3cf0: 0x0004, 0x3cf1: 0x0004, 0x3cf2: 0x0004, 0x3cf3: 0x0004, 0x3cf4: 0x0004, 0x3cf5: 0x0004, + 0x3cf6: 0x0004, 0x3cf7: 0x0004, 0x3cf8: 0x0004, 0x3cf9: 0x0004, 0x3cfa: 0x0004, 0x3cfb: 0x0004, + 0x3cfc: 0x0004, 0x3cfd: 0x0004, 0x3cfe: 0x0004, 0x3cff: 0x0004, + // Block 0xf4, offset 0x3d00 + 0x3d00: 0x0004, 0x3d01: 0x0004, 0x3d02: 0x0004, 0x3d03: 0x0004, 0x3d04: 0x0004, 0x3d05: 0x0004, + 0x3d06: 0x0004, + 0x3d0e: 0x0004, 0x3d0f: 0x0004, 0x3d10: 0x0004, 0x3d11: 0x0004, + 0x3d12: 0x0004, 0x3d13: 0x0004, 0x3d14: 0x0004, 0x3d15: 0x0004, 0x3d16: 0x0004, 0x3d17: 0x0004, + 0x3d18: 0x0004, 0x3d19: 0x0004, 0x3d1a: 0x0004, 0x3d1b: 0x0004, 0x3d1c: 0x0004, + 0x3d1f: 0x0004, 0x3d20: 0x0004, 0x3d21: 0x0004, 0x3d22: 0x0004, 0x3d23: 0x0004, + 0x3d24: 0x0004, 0x3d25: 0x0004, 0x3d26: 0x0004, 0x3d27: 0x0004, 0x3d28: 0x0004, 0x3d29: 0x0004, + 0x3d30: 0x0004, 0x3d31: 0x0004, 0x3d32: 0x0004, 0x3d33: 0x0004, 0x3d34: 0x0004, 0x3d35: 0x0004, + 0x3d36: 0x0004, 0x3d37: 0x0004, 0x3d38: 0x0004, + // Block 0xf5, offset 0x3d40 + 0x3d40: 0x0002, 0x3d41: 0x0002, 0x3d42: 0x0002, 0x3d43: 0x0002, 0x3d44: 0x0002, 0x3d45: 0x0002, + 0x3d46: 0x0002, 0x3d47: 0x0002, 0x3d48: 0x0002, 0x3d49: 0x0002, 0x3d4a: 0x0002, 0x3d4b: 0x0002, + 0x3d4c: 0x0002, 0x3d4d: 0x0002, 0x3d4e: 0x0002, 0x3d4f: 0x0002, 0x3d50: 0x0002, 0x3d51: 0x0002, + 0x3d52: 0x0002, 0x3d53: 0x0002, 0x3d54: 0x0002, 0x3d55: 0x0002, 0x3d56: 0x0002, 0x3d57: 0x0002, + 0x3d58: 0x0002, 0x3d59: 0x0002, 0x3d5a: 0x0002, 0x3d5b: 0x0002, 0x3d5c: 0x0002, 0x3d5d: 0x0002, + 0x3d5e: 0x0002, 0x3d5f: 0x0002, 0x3d60: 0x0002, 0x3d61: 0x0002, 0x3d62: 0x0002, 0x3d63: 0x0002, + 0x3d64: 0x0002, 0x3d65: 0x0002, 0x3d66: 0x0002, 0x3d67: 0x0002, 0x3d68: 0x0002, 0x3d69: 0x0002, + 0x3d6a: 0x0002, 0x3d6b: 0x0002, 0x3d6c: 0x0002, 0x3d6d: 0x0002, 0x3d6e: 0x0002, 0x3d6f: 0x0002, + 0x3d70: 0x0002, 0x3d71: 0x0002, 0x3d72: 0x0002, 0x3d73: 0x0002, 0x3d74: 0x0002, 0x3d75: 0x0002, + 0x3d76: 0x0002, 0x3d77: 0x0002, 0x3d78: 0x0002, 0x3d79: 0x0002, 0x3d7a: 0x0002, 0x3d7b: 0x0002, + 0x3d7c: 0x0002, 0x3d7d: 0x0002, + // Block 0xf6, offset 0x3d80 + 0x3d81: 0x0001, + 0x3da0: 0x0001, 0x3da1: 0x0001, 0x3da2: 0x0001, 0x3da3: 0x0001, + 0x3da4: 0x0001, 0x3da5: 0x0001, 0x3da6: 0x0001, 0x3da7: 0x0001, 0x3da8: 0x0001, 0x3da9: 0x0001, + 0x3daa: 0x0001, 0x3dab: 0x0001, 0x3dac: 0x0001, 0x3dad: 0x0001, 0x3dae: 0x0001, 0x3daf: 0x0001, + 0x3db0: 0x0001, 0x3db1: 0x0001, 0x3db2: 0x0001, 0x3db3: 0x0001, 0x3db4: 0x0001, 0x3db5: 0x0001, + 0x3db6: 0x0001, 0x3db7: 0x0001, 0x3db8: 0x0001, 0x3db9: 0x0001, 0x3dba: 0x0001, 0x3dbb: 0x0001, + 0x3dbc: 0x0001, 0x3dbd: 0x0001, 0x3dbe: 0x0001, 0x3dbf: 0x0001, + // Block 0xf7, offset 0x3dc0 + 0x3dc0: 0x0003, 0x3dc1: 0x0003, 0x3dc2: 0x0003, 0x3dc3: 0x0003, 0x3dc4: 0x0003, 0x3dc5: 0x0003, + 0x3dc6: 0x0003, 0x3dc7: 0x0003, 0x3dc8: 0x0003, 0x3dc9: 0x0003, 0x3dca: 0x0003, 0x3dcb: 0x0003, + 0x3dcc: 0x0003, 0x3dcd: 0x0003, 0x3dce: 0x0003, 0x3dcf: 0x0003, 0x3dd0: 0x0003, 0x3dd1: 0x0003, + 0x3dd2: 0x0003, 0x3dd3: 0x0003, 0x3dd4: 0x0003, 0x3dd5: 0x0003, 0x3dd6: 0x0003, 0x3dd7: 0x0003, + 0x3dd8: 0x0003, 0x3dd9: 0x0003, 0x3dda: 0x0003, 0x3ddb: 0x0003, 0x3ddc: 0x0003, 0x3ddd: 0x0003, + 0x3dde: 0x0003, 0x3ddf: 0x0003, 0x3de0: 0x0003, 0x3de1: 0x0003, 0x3de2: 0x0003, 0x3de3: 0x0003, + 0x3de4: 0x0003, 0x3de5: 0x0003, 0x3de6: 0x0003, 0x3de7: 0x0003, 0x3de8: 0x0003, 0x3de9: 0x0003, + 0x3dea: 0x0003, 0x3deb: 0x0003, 0x3dec: 0x0003, 0x3ded: 0x0003, 0x3dee: 0x0003, 0x3def: 0x0003, + 0x3df0: 0x0003, 0x3df1: 0x0003, 0x3df2: 0x0003, 0x3df3: 0x0003, 0x3df4: 0x0003, 0x3df5: 0x0003, + 0x3df6: 0x0003, 0x3df7: 0x0003, 0x3df8: 0x0003, 0x3df9: 0x0003, 0x3dfa: 0x0003, 0x3dfb: 0x0003, + 0x3dfc: 0x0003, 0x3dfd: 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: 0xc1, + 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: 0xc2, 0x474: 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: 0xe5, 0x5d3: 0xe6, 0x5d4: 0xe7, 0x5d5: 0xe8, 0x5d6: 0xe9, 0x5d7: 0xea, + 0x5d8: 0xe5, 0x5d9: 0xeb, 0x5da: 0xe5, 0x5db: 0xec, 0x5df: 0xed, + 0x5e4: 0xee, 0x5e5: 0xef, 0x5e6: 0xe5, 0x5e7: 0xe5, + 0x5e9: 0xf0, 0x5ea: 0xf1, 0x5eb: 0xf2, + // 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: 0xf3, + // 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: 0xf4, 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: 0xf5, + // 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/width.go b/vendor/github.com/clipperhouse/displaywidth/width.go new file mode 100644 index 0000000..55dd458 --- /dev/null +++ b/vendor/github.com/clipperhouse/displaywidth/width.go @@ -0,0 +1,179 @@ +package displaywidth + +import ( + "unicode/utf8" + + "github.com/clipperhouse/stringish" + "github.com/clipperhouse/uax29/v2/graphemes" +) + +// Options allows you to specify the treatment of ambiguous East Asian +// characters. When EastAsianWidth is false (default), ambiguous East Asian +// characters are treated as width 1. When EastAsianWidth is true, ambiguous +// East Asian characters are treated as width 2. +type Options struct { + EastAsianWidth bool +} + +// DefaultOptions is the default options for the display width +// calculation, which is EastAsianWidth: false. +var DefaultOptions = Options{EastAsianWidth: false} + +// 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 { + // Optimization: no need to parse grapheme + switch len(s) { + case 0: + return 0 + case 1: + return asciiWidth(s[0]) + } + + width := 0 + g := graphemes.FromString(s) + for g.Next() { + width += graphemeWidth(g.Value(), options) + } + 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 { + // Optimization: no need to parse grapheme + switch len(s) { + case 0: + return 0 + case 1: + return asciiWidth(s[0]) + } + + width := 0 + g := graphemes.FromBytes(s) + for g.Next() { + width += graphemeWidth(g.Value(), options) + } + 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 stringish.Interface](s T, options Options) int { + // Optimization: no need to look up properties + switch len(s) { + case 0: + return 0 + case 1: + return asciiWidth(s[0]) + } + + p, sz := lookup(s) + prop := property(p) + + // Variation Selector 16 (VS16) requests emoji presentation + if sz > 0 && len(s) >= sz+3 { + vs := s[sz : sz+3] + if isVS16(vs) { + prop = _Emoji + } + // 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. + } + + /* + Note: we previously had some regional indicator handling here, + intending to treat single RI's as width 1 and pairs as width 2. + We think that's what the Unicode #11 indicates? + + Then we looked at what actual terminals do, and they seem to treat + single and paired RI's as width 2, regardless. See terminal-test/. + Looks like VS Code does the same FWIW. + */ + + if options.EastAsianWidth && prop == _East_Asian_Ambiguous { + prop = _East_Asian_Wide + } + + if prop > upperBound { + prop = _Default + } + + return propertyWidths[prop] +} + +func asciiWidth(b byte) int { + if b <= 0x1F || b == 0x7F { + return 0 + } + return 1 +} + +// isVS16 checks if the slice matches VS16 (U+FE0F) UTF-8 encoding +// (EF B8 8F). It assumes len(s) >= 3. +func isVS16[T stringish.Interface](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 = [6]int{ + _Default: 1, + _Zero_Width: 0, + _East_Asian_Wide: 2, + _East_Asian_Ambiguous: 1, + _Emoji: 2, + _Regional_Indicator: 2, +} + +const upperBound = property(len(propertyWidths) - 1) diff --git a/vendor/github.com/etkecc/go-kit/utils.go b/vendor/github.com/etkecc/go-kit/utils.go index 26c3f61..9b00953 100644 --- a/vendor/github.com/etkecc/go-kit/utils.go +++ b/vendor/github.com/etkecc/go-kit/utils.go @@ -1,6 +1,9 @@ package kit -import "crypto/subtle" +import ( + "crypto/subtle" + "reflect" +) // Eq checks if 2 strings are equal in constant time func Eq(s1, s2 string) bool { @@ -8,3 +11,33 @@ func Eq(s1, s2 string) bool { b2 := []byte(s2) return subtle.ConstantTimeEq(int32(len(b1)), int32(len(b2))) == 1 && subtle.ConstantTimeCompare(b1, b2) == 1 //nolint:gosec // that's ok } + +// IsNil checks if the given value is nil, including interfaces holding nil pointers +func IsNil(i any) bool { + // standard nil check + if i == nil { + return true + } + + // special case: interfaces holding nil pointers (e.g. var x *int = nil; var y any = x) + rv := reflect.ValueOf(i) + for rv.Kind() == reflect.Pointer { + if rv.IsNil() { + return true + } + rv = rv.Elem() + } + + // check for other kinds that can be nil + switch rv.Kind() { + case reflect.Chan, + reflect.Func, + reflect.Map, + reflect.Pointer, + reflect.Slice, + reflect.UnsafePointer: + return rv.IsNil() + default: + return false + } +} diff --git a/vendor/github.com/getsentry/sentry-go/.codecov.yml b/vendor/github.com/getsentry/sentry-go/.codecov.yml index 557e1aa..0c0e695 100644 --- a/vendor/github.com/getsentry/sentry-go/.codecov.yml +++ b/vendor/github.com/getsentry/sentry-go/.codecov.yml @@ -11,5 +11,9 @@ coverage: default: # Do not fail the commit status if the coverage was reduced up to this value threshold: 0.5% + patch: + default: + informational: true ignore: - "log_fallback.go" + - "internal/testutils" diff --git a/vendor/github.com/getsentry/sentry-go/CHANGELOG.md b/vendor/github.com/getsentry/sentry-go/CHANGELOG.md index d8beaa0..821d303 100644 --- a/vendor/github.com/getsentry/sentry-go/CHANGELOG.md +++ b/vendor/github.com/getsentry/sentry-go/CHANGELOG.md @@ -1,5 +1,71 @@ # Changelog +## 0.40.0 + +The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.40.0. + +### Bug Fixes + +- Disable `DisableTelemetryBuffer` flag and noop Telemetry Buffer, to prevent a panic at runtime ([#1149](https://github.com/getsentry/sentry-go/pull/1149)). + +## 0.39.0 + +The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.39.0. + +### Features + +- Drop events from the telemetry buffer when rate-limited or transport is full, allowing the buffer queue to empty itself under load ([#1138](https://github.com/getsentry/sentry-go/pull/1138)). + +### Bug Fixes + +- Fix scheduler's `hasWork()` method to check if buffers are ready to flush. The previous implementation was causing CPU spikes ([#1143](https://github.com/getsentry/sentry-go/pull/1143)). + +## 0.38.0 + +### Breaking Changes + +### Features + +- Introduce a new async envelope transport and telemetry buffer to prioritize and batch events ([#1094](https://github.com/getsentry/sentry-go/pull/1094), [#1093](https://github.com/getsentry/sentry-go/pull/1093), [#1107](https://github.com/getsentry/sentry-go/pull/1107)). + - Advantages: + - Prioritized, per-category buffers (errors, transactions, logs, check-ins) reduce starvation and improve resilience under load + - Batching for high-volume logs (up to 100 items or 5s) cuts network overhead + - Bounded memory with eviction policies + - Improved flush behavior with context-aware flushing +- Add `ClientOptions.DisableTelemetryBuffer` to opt out and fall back to the legacy transport layer (`HTTPTransport` / `HTTPSyncTransport`). + + ```go + err := sentry.Init(sentry.ClientOptions{ + Dsn: "__DSN__", + DisableTelemetryBuffer: true, // fallback to legacy transport + }) + ``` + +### Notes + +- If a custom `Transport` is provided, the SDK automatically disables the telemetry buffer and uses the legacy transport for compatibility. + +## 0.37.0 + +The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.37.0. + +### Breaking Changes + +- Behavioral change for the `TraceIgnoreStatusCodes` option. The option now defaults to ignoring 404 status codes ([#1122](https://github.com/getsentry/sentry-go/pull/1122)). + +### Features + +- Add `sentry.origin` attribute to structured logs to identify log origin for `slog` and `logrus` integrations (`auto.log.slog`, `auto.log.logrus`) ([#1121](https://github.com/getsentry/sentry-go/pull/1121)). + +### Bug Fixes + +- Fix `slog` event handler to use the initial context, ensuring events use the correct hub/span when the emission context lacks one ([#1133](https://github.com/getsentry/sentry-go/pull/1133)). +- Improve exception chain processing by checking pointer values when tracking visited errors, avoiding instability for certain wrapped errors ([#1132](https://github.com/getsentry/sentry-go/pull/1132)). + +### Misc + +- Bump `golang.org/x/net` to v0.38.0 ([#1126](https://github.com/getsentry/sentry-go/pull/1126)). + ## 0.36.2 The Sentry SDK team is happy to announce the immediate availability of Sentry Go SDK v0.36.2. diff --git a/vendor/github.com/getsentry/sentry-go/Makefile b/vendor/github.com/getsentry/sentry-go/Makefile index 26d993e..6b98f50 100644 --- a/vendor/github.com/getsentry/sentry-go/Makefile +++ b/vendor/github.com/getsentry/sentry-go/Makefile @@ -70,7 +70,7 @@ mod-tidy: ## Check go.mod tidiness set -e ; \ for dir in $(ALL_GO_MOD_DIRS); do \ echo ">>> Running 'go mod tidy' for module: $${dir}"; \ - (cd "$${dir}" && go mod tidy -go=1.23 -compat=1.23); \ + (cd "$${dir}" && GOTOOLCHAIN=local go mod tidy -go=1.23.0 -compat=1.23); \ done; \ git diff --exit-code; .PHONY: mod-tidy diff --git a/vendor/github.com/getsentry/sentry-go/README.md b/vendor/github.com/getsentry/sentry-go/README.md index 59a989d..1941fa0 100644 --- a/vendor/github.com/getsentry/sentry-go/README.md +++ b/vendor/github.com/getsentry/sentry-go/README.md @@ -13,6 +13,7 @@ [![Build Status](https://github.com/getsentry/sentry-go/actions/workflows/test.yml/badge.svg)](https://github.com/getsentry/sentry-go/actions/workflows/test.yml) [![Go Report Card](https://goreportcard.com/badge/github.com/getsentry/sentry-go)](https://goreportcard.com/report/github.com/getsentry/sentry-go) [![Discord](https://img.shields.io/discord/621778831602221064)](https://discord.gg/Ww9hbqr) +[![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry) [![go.dev](https://img.shields.io/badge/go.dev-pkg-007d9c.svg?style=flat)](https://pkg.go.dev/github.com/getsentry/sentry-go) `sentry-go` provides a Sentry client implementation for the Go programming diff --git a/vendor/github.com/getsentry/sentry-go/client.go b/vendor/github.com/getsentry/sentry-go/client.go index 3462302..3aa267f 100644 --- a/vendor/github.com/getsentry/sentry-go/client.go +++ b/vendor/github.com/getsentry/sentry-go/client.go @@ -15,6 +15,10 @@ import ( "github.com/getsentry/sentry-go/internal/debug" "github.com/getsentry/sentry-go/internal/debuglog" + httpInternal "github.com/getsentry/sentry-go/internal/http" + "github.com/getsentry/sentry-go/internal/protocol" + "github.com/getsentry/sentry-go/internal/ratelimit" + "github.com/getsentry/sentry-go/internal/telemetry" ) // The identifier of the SDK. @@ -247,8 +251,13 @@ type ClientOptions struct { // [][]int{{404}, {500}} // ignore status codes 404 and 500 // [][]int{{404}, {400, 405}, {500, 599}} // ignore 404, range 400-405, and range 500-599 // - // By default, this is empty and all status codes are traced. + // By default, this ignores 404 status codes. + // + // IMPORTANT: to not ignore any status codes, the option should be an empty slice and not nil. The nil option is + // used for defaulting to 404 ignores. TraceIgnoreStatusCodes [][]int + // DisableTelemetryBuffer disables the telemetry buffer layer for prioritizing events and uses the old transport layer. + DisableTelemetryBuffer bool } // Client is the underlying processor that is used by the main API and Hub @@ -263,8 +272,9 @@ type Client struct { sdkVersion string // Transport is read-only. Replacing the transport of an existing client is // not supported, create a new client instead. - Transport Transport - batchLogger *BatchLogger + Transport Transport + batchLogger *BatchLogger + telemetryBuffer *telemetry.Buffer } // NewClient creates and returns an instance of Client configured using @@ -325,6 +335,10 @@ func NewClient(options ClientOptions) (*Client, error) { options.MaxSpans = defaultMaxSpans } + if options.TraceIgnoreStatusCodes == nil { + options.TraceIgnoreStatusCodes = [][]int{{404}} + } + // SENTRYGODEBUG is a comma-separated list of key=value pairs (similar // to GODEBUG). It is not a supported feature: recognized debug options // may change any time. @@ -364,12 +378,17 @@ func NewClient(options ClientOptions) (*Client, error) { sdkVersion: SDKVersion, } + client.setupTransport() + + // noop Telemetry Buffers fow now + // if !options.DisableTelemetryBuffer { + // client.setupTelemetryBuffer() + // } else if options.EnableLogs { client.batchLogger = NewBatchLogger(&client) client.batchLogger.Start() } - client.setupTransport() client.setupIntegrations() return &client, nil @@ -391,6 +410,52 @@ func (client *Client) setupTransport() { client.Transport = transport } +func (client *Client) setupTelemetryBuffer() { // nolint: unused + if client.options.DisableTelemetryBuffer { + return + } + + if client.dsn == nil { + debuglog.Println("Telemetry buffer disabled: no DSN configured") + return + } + + // We currently disallow using custom Transport with the new Telemetry Buffer, due to the difference in transport signatures. + // The option should be enabled when the new Transport interface signature changes. + if client.options.Transport != nil { + debuglog.Println("Cannot enable Telemetry Buffer with custom Transport: fallback to old transport") + if client.options.EnableLogs { + client.batchLogger = NewBatchLogger(client) + client.batchLogger.Start() + } + return + } + + transport := httpInternal.NewAsyncTransport(httpInternal.TransportOptions{ + Dsn: client.options.Dsn, + HTTPClient: client.options.HTTPClient, + HTTPTransport: client.options.HTTPTransport, + HTTPProxy: client.options.HTTPProxy, + HTTPSProxy: client.options.HTTPSProxy, + CaCerts: client.options.CaCerts, + }) + client.Transport = &internalAsyncTransportAdapter{transport: transport} + + storage := map[ratelimit.Category]telemetry.Storage[protocol.EnvelopeItemConvertible]{ + ratelimit.CategoryError: telemetry.NewRingBuffer[protocol.EnvelopeItemConvertible](ratelimit.CategoryError, 100, telemetry.OverflowPolicyDropOldest, 1, 0), + ratelimit.CategoryTransaction: telemetry.NewRingBuffer[protocol.EnvelopeItemConvertible](ratelimit.CategoryTransaction, 1000, telemetry.OverflowPolicyDropOldest, 1, 0), + ratelimit.CategoryLog: telemetry.NewRingBuffer[protocol.EnvelopeItemConvertible](ratelimit.CategoryLog, 10*100, telemetry.OverflowPolicyDropOldest, 100, 5*time.Second), + ratelimit.CategoryMonitor: telemetry.NewRingBuffer[protocol.EnvelopeItemConvertible](ratelimit.CategoryMonitor, 100, telemetry.OverflowPolicyDropOldest, 1, 0), + } + + sdkInfo := &protocol.SdkInfo{ + Name: client.sdkIdentifier, + Version: client.sdkVersion, + } + + client.telemetryBuffer = telemetry.NewBuffer(storage, transport, &client.dsn.Dsn, sdkInfo) +} + func (client *Client) setupIntegrations() { integrations := []Integration{ new(contextifyFramesIntegration), @@ -531,7 +596,7 @@ func (client *Client) RecoverWithContext( // the network synchronously, configure it to use the HTTPSyncTransport in the // call to Init. func (client *Client) Flush(timeout time.Duration) bool { - if client.batchLogger != nil { + if client.batchLogger != nil || client.telemetryBuffer != nil { ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() return client.FlushWithContext(ctx) @@ -555,6 +620,9 @@ func (client *Client) FlushWithContext(ctx context.Context) bool { if client.batchLogger != nil { client.batchLogger.Flush(ctx.Done()) } + if client.telemetryBuffer != nil { + return client.telemetryBuffer.FlushWithContext(ctx) + } return client.Transport.FlushWithContext(ctx) } @@ -563,6 +631,12 @@ func (client *Client) FlushWithContext(ctx context.Context) bool { // Close should be called after Flush and before terminating the program // otherwise some events may be lost. func (client *Client) Close() { + if client.telemetryBuffer != nil { + client.telemetryBuffer.Close(5 * time.Second) + } + if client.batchLogger != nil { + client.batchLogger.Shutdown() + } client.Transport.Close() } @@ -683,7 +757,13 @@ func (client *Client) processEvent(event *Event, hint *EventHint, scope EventMod } } - client.Transport.SendEvent(event) + if client.telemetryBuffer != nil { + if !client.telemetryBuffer.Add(event) { + debuglog.Println("Event dropped: telemetry buffer full or unavailable") + } + } else { + client.Transport.SendEvent(event) + } return &event.EventID } diff --git a/vendor/github.com/getsentry/sentry-go/exception.go b/vendor/github.com/getsentry/sentry-go/exception.go index 9505c99..f7ef4a0 100644 --- a/vendor/github.com/getsentry/sentry-go/exception.go +++ b/vendor/github.com/getsentry/sentry-go/exception.go @@ -14,21 +14,18 @@ const ( ) type visited struct { - comparable map[error]struct{} - msgs map[string]struct{} + ptrs map[uintptr]struct{} + msgs map[string]struct{} } func (v *visited) seenError(err error) bool { - t := reflect.TypeOf(err) - if t == nil { - return false - } - - if t.Comparable() { - if _, ok := v.comparable[err]; ok { + t := reflect.ValueOf(err) + if t.Kind() == reflect.Ptr && !t.IsNil() { + ptr := t.Pointer() + if _, ok := v.ptrs[ptr]; ok { return true } - v.comparable[err] = struct{}{} + v.ptrs[ptr] = struct{}{} return false } @@ -43,8 +40,8 @@ func (v *visited) seenError(err error) bool { func convertErrorToExceptions(err error, maxErrorDepth int) []Exception { var exceptions []Exception vis := &visited{ - make(map[error]struct{}), - make(map[string]struct{}), + ptrs: make(map[uintptr]struct{}), + msgs: make(map[string]struct{}), } convertErrorDFS(err, &exceptions, nil, "", vis, maxErrorDepth, 0) diff --git a/vendor/github.com/getsentry/sentry-go/interfaces.go b/vendor/github.com/getsentry/sentry-go/interfaces.go index ea2f8d8..d7c197d 100644 --- a/vendor/github.com/getsentry/sentry-go/interfaces.go +++ b/vendor/github.com/getsentry/sentry-go/interfaces.go @@ -493,6 +493,70 @@ func (e *Event) ToEnvelopeWithTime(dsn *protocol.Dsn, sentAt time.Time) (*protoc return envelope, nil } +// ToEnvelopeItem converts the Event to a Sentry envelope item. +func (e *Event) ToEnvelopeItem() (*protocol.EnvelopeItem, error) { + eventBody, err := json.Marshal(e) + if err != nil { + // Try fallback: remove problematic fields and retry + e.Breadcrumbs = nil + e.Contexts = nil + e.Extra = map[string]interface{}{ + "info": fmt.Sprintf("Could not encode original event as JSON. "+ + "Succeeded by removing Breadcrumbs, Contexts and Extra. "+ + "Please verify the data you attach to the scope. "+ + "Error: %s", err), + } + + eventBody, err = json.Marshal(e) + if err != nil { + return nil, fmt.Errorf("event could not be marshaled even with fallback: %w", err) + } + + DebugLogger.Printf("Event marshaling succeeded with fallback after removing problematic fields") + } + + // TODO: all event types should be abstracted to implement EnvelopeItemConvertible and convert themselves. + var item *protocol.EnvelopeItem + switch e.Type { + case transactionType: + item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeTransaction, eventBody) + case checkInType: + item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeCheckIn, eventBody) + case logEvent.Type: + item = protocol.NewLogItem(len(e.Logs), eventBody) + default: + item = protocol.NewEnvelopeItem(protocol.EnvelopeItemTypeEvent, eventBody) + } + + return item, nil +} + +// GetCategory returns the rate limit category for this event. +func (e *Event) GetCategory() ratelimit.Category { + return e.toCategory() +} + +// GetEventID returns the event ID. +func (e *Event) GetEventID() string { + return string(e.EventID) +} + +// GetSdkInfo returns SDK information for the envelope header. +func (e *Event) GetSdkInfo() *protocol.SdkInfo { + return &e.Sdk +} + +// GetDynamicSamplingContext returns trace context for the envelope header. +func (e *Event) GetDynamicSamplingContext() map[string]string { + trace := make(map[string]string) + if dsc := e.sdkMetaData.dsc; dsc.HasEntries() { + for k, v := range dsc.Entries { + trace[k] = v + } + } + return trace +} + // TODO: Event.Contexts map[string]interface{} => map[string]EventContext, // to prevent accidentally storing T when we mean *T. // For example, the TraceContext must be stored as *TraceContext to pick up the @@ -667,6 +731,69 @@ type Log struct { Attributes map[string]Attribute `json:"attributes,omitempty"` } +// ToEnvelopeItem converts the Log to a Sentry envelope item for batching. +func (l *Log) ToEnvelopeItem() (*protocol.EnvelopeItem, error) { + type logJSON struct { + Timestamp *float64 `json:"timestamp,omitempty"` + TraceID string `json:"trace_id,omitempty"` + Level string `json:"level"` + Severity int `json:"severity_number,omitempty"` + Body string `json:"body,omitempty"` + Attributes map[string]protocol.LogAttribute `json:"attributes,omitempty"` + } + + // Convert time.Time to seconds float if set + var ts *float64 + if !l.Timestamp.IsZero() { + sec := float64(l.Timestamp.UnixNano()) / 1e9 + ts = &sec + } + + attrs := make(map[string]protocol.LogAttribute, len(l.Attributes)) + for k, v := range l.Attributes { + attrs[k] = protocol.LogAttribute{Value: v.Value, Type: string(v.Type)} + } + + logData, err := json.Marshal(logJSON{ + Timestamp: ts, + TraceID: l.TraceID.String(), + Level: string(l.Level), + Severity: l.Severity, + Body: l.Body, + Attributes: attrs, + }) + if err != nil { + return nil, err + } + + return &protocol.EnvelopeItem{ + Header: &protocol.EnvelopeItemHeader{ + Type: protocol.EnvelopeItemTypeLog, + }, + Payload: logData, + }, nil +} + +// GetCategory returns the rate limit category for logs. +func (l *Log) GetCategory() ratelimit.Category { + return ratelimit.CategoryLog +} + +// GetEventID returns empty string (event ID set when batching). +func (l *Log) GetEventID() string { + return "" +} + +// GetSdkInfo returns nil (SDK info set when batching). +func (l *Log) GetSdkInfo() *protocol.SdkInfo { + return nil +} + +// GetDynamicSamplingContext returns nil (trace context set when batching). +func (l *Log) GetDynamicSamplingContext() map[string]string { + return nil +} + type AttrType string const ( diff --git a/vendor/github.com/getsentry/sentry-go/internal/http/transport.go b/vendor/github.com/getsentry/sentry-go/internal/http/transport.go index 52cb32b..e826759 100644 --- a/vendor/github.com/getsentry/sentry-go/internal/http/transport.go +++ b/vendor/github.com/getsentry/sentry-go/internal/http/transport.go @@ -33,6 +33,7 @@ const ( var ( ErrTransportQueueFull = errors.New("transport queue full") ErrTransportClosed = errors.New("transport is closed") + ErrEmptyEnvelope = errors.New("empty envelope provided") ) type TransportOptions struct { @@ -196,31 +197,15 @@ func (t *SyncTransport) SendEnvelope(envelope *protocol.Envelope) error { func (t *SyncTransport) Close() {} -func (t *SyncTransport) SendEvent(event protocol.EnvelopeConvertible) { - envelope, err := event.ToEnvelope(t.dsn) - if err != nil { - debuglog.Printf("Failed to convert to envelope: %v", err) - return - } - - if envelope == nil { - debuglog.Printf("Error: event with empty envelope") - return - } - - if err := t.SendEnvelope(envelope); err != nil { - debuglog.Printf("Error sending the envelope: %v", err) - } -} - func (t *SyncTransport) IsRateLimited(category ratelimit.Category) bool { return t.disabled(category) } +func (t *SyncTransport) HasCapacity() bool { return true } + func (t *SyncTransport) SendEnvelopeWithContext(ctx context.Context, envelope *protocol.Envelope) error { - if envelope == nil { - debuglog.Printf("Error: provided empty envelope") - return nil + if envelope == nil || len(envelope.Items) == 0 { + return ErrEmptyEnvelope } category := categoryFromEnvelope(envelope) @@ -233,6 +218,14 @@ func (t *SyncTransport) SendEnvelopeWithContext(ctx context.Context, envelope *p debuglog.Printf("There was an issue creating the request: %v", err) return err } + debuglog.Printf( + "Sending %s [%s] to %s project: %s", + envelope.Items[0].Header.Type, + envelope.Header.EventID, + t.dsn.GetHost(), + t.dsn.GetProjectID(), + ) + response, err := t.client.Do(request) if err != nil { debuglog.Printf("There was an issue with sending an event: %v", err) @@ -354,6 +347,19 @@ func (t *AsyncTransport) start() { }) } +// HasCapacity reports whether the async transport queue appears to have space +// for at least one more envelope. This is a best-effort, non-blocking check. +func (t *AsyncTransport) HasCapacity() bool { + t.mu.RLock() + defer t.mu.RUnlock() + select { + case <-t.done: + return false + default: + } + return len(t.queue) < cap(t.queue) +} + func (t *AsyncTransport) SendEnvelope(envelope *protocol.Envelope) error { select { case <-t.done: @@ -361,6 +367,10 @@ func (t *AsyncTransport) SendEnvelope(envelope *protocol.Envelope) error { default: } + if envelope == nil || len(envelope.Items) == 0 { + return ErrEmptyEnvelope + } + category := categoryFromEnvelope(envelope) if t.isRateLimited(category) { return nil @@ -368,6 +378,13 @@ func (t *AsyncTransport) SendEnvelope(envelope *protocol.Envelope) error { select { case t.queue <- envelope: + debuglog.Printf( + "Sending %s [%s] to %s project: %s", + envelope.Items[0].Header.Type, + envelope.Header.EventID, + t.dsn.GetHost(), + t.dsn.GetProjectID(), + ) return nil default: atomic.AddInt64(&t.droppedCount, 1) @@ -375,23 +392,6 @@ func (t *AsyncTransport) SendEnvelope(envelope *protocol.Envelope) error { } } -func (t *AsyncTransport) SendEvent(event protocol.EnvelopeConvertible) { - envelope, err := event.ToEnvelope(t.dsn) - if err != nil { - debuglog.Printf("Failed to convert to envelope: %v", err) - return - } - - if envelope == nil { - debuglog.Printf("Error: event with empty envelope") - return - } - - if err := t.SendEnvelope(envelope); err != nil { - debuglog.Printf("Error sending the envelope: %v", err) - } -} - func (t *AsyncTransport) Flush(timeout time.Duration) bool { ctx, cancel := context.WithTimeout(context.Background(), timeout) defer cancel() @@ -404,11 +404,14 @@ func (t *AsyncTransport) FlushWithContext(ctx context.Context) bool { case t.flushRequest <- flushResponse: select { case <-flushResponse: + debuglog.Println("Buffer flushed successfully.") return true case <-ctx.Done(): + debuglog.Println("Failed to flush, buffer timed out.") return false } case <-ctx.Done(): + debuglog.Println("Failed to flush, buffer timed out.") return false } } @@ -550,10 +553,6 @@ func (t *NoopTransport) SendEnvelope(_ *protocol.Envelope) error { return nil } -func (t *NoopTransport) SendEvent(_ protocol.EnvelopeConvertible) { - debuglog.Println("Event dropped due to NoopTransport usage.") -} - func (t *NoopTransport) IsRateLimited(_ ratelimit.Category) bool { return false } @@ -569,3 +568,5 @@ func (t *NoopTransport) FlushWithContext(_ context.Context) bool { func (t *NoopTransport) Close() { // Nothing to close } + +func (t *NoopTransport) HasCapacity() bool { return true } diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go index 6f6f29a..6b425b1 100644 --- a/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go +++ b/vendor/github.com/getsentry/sentry-go/internal/protocol/interfaces.go @@ -7,12 +7,23 @@ import ( "github.com/getsentry/sentry-go/internal/ratelimit" ) -// EnvelopeConvertible represents any type that can be converted to a Sentry envelope. -// This interface allows the telemetry buffers to be generic while still working with -// concrete types like Event. -type EnvelopeConvertible interface { - // ToEnvelope converts the item to a Sentry envelope. - ToEnvelope(dsn *Dsn) (*Envelope, error) +// EnvelopeItemConvertible represents any type that can be converted to a Sentry envelope item. +// This interface allows the telemetry buffers to work with items that can be batched together. +type EnvelopeItemConvertible interface { + // ToEnvelopeItem converts the item to a Sentry envelope item. + ToEnvelopeItem() (*EnvelopeItem, error) + + // GetCategory returns the rate limit category for this item. + GetCategory() ratelimit.Category + + // GetEventID returns the event ID for this item. + GetEventID() string + + // GetSdkInfo returns SDK information for the envelope header. + GetSdkInfo() *SdkInfo + + // GetDynamicSamplingContext returns trace context for the envelope header. + GetDynamicSamplingContext() map[string]string } // TelemetryTransport represents the envelope-first transport interface. @@ -23,8 +34,8 @@ type TelemetryTransport interface { // backpressure error if the queue is full. SendEnvelope(envelope *Envelope) error - // SendEvent sends an event to Sentry. - SendEvent(event EnvelopeConvertible) + // HasCapacity reports whether the transport has capacity to accept at least one more envelope. + HasCapacity() bool // IsRateLimited checks if a specific category is currently rate limited IsRateLimited(category ratelimit.Category) bool diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go new file mode 100644 index 0000000..2860ed8 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/protocol/log_batch.go @@ -0,0 +1,48 @@ +package protocol + +import ( + "encoding/json" + + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +// LogAttribute is the JSON representation for a single log attribute value. +type LogAttribute struct { + Value any `json:"value"` + Type string `json:"type"` +} + +// Logs is a container for multiple log items which knows how to convert +// itself into a single batched log envelope item. +type Logs []EnvelopeItemConvertible + +func (ls Logs) ToEnvelopeItem() (*EnvelopeItem, error) { + // Convert each log to its JSON representation + items := make([]json.RawMessage, 0, len(ls)) + for _, log := range ls { + envItem, err := log.ToEnvelopeItem() + if err != nil { + continue + } + items = append(items, envItem.Payload) + } + + if len(items) == 0 { + return nil, nil + } + + wrapper := struct { + Items []json.RawMessage `json:"items"` + }{Items: items} + + payload, err := json.Marshal(wrapper) + if err != nil { + return nil, err + } + return NewLogItem(len(ls), payload), nil +} + +func (Logs) GetCategory() ratelimit.Category { return ratelimit.CategoryLog } +func (Logs) GetEventID() string { return "" } +func (Logs) GetSdkInfo() *SdkInfo { return nil } +func (Logs) GetDynamicSamplingContext() map[string]string { return nil } diff --git a/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go b/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go new file mode 100644 index 0000000..5aff3b1 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/protocol/uuid.go @@ -0,0 +1,18 @@ +package protocol + +import ( + "crypto/rand" + "encoding/hex" +) + +// GenerateEventID generates a random UUID v4 for use as a Sentry event ID. +func GenerateEventID() string { + id := make([]byte, 16) + // Prefer rand.Read over rand.Reader, see https://go-review.googlesource.com/c/go/+/272326/. + _, _ = rand.Read(id) + id[6] &= 0x0F // clear version + id[6] |= 0x40 // set version to 4 (random uuid) + id[8] &= 0x3F // clear variant + id[8] |= 0x80 // set to IETF variant + return hex.EncodeToString(id) +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go index 971cba7..0a5604e 100644 --- a/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go +++ b/vendor/github.com/getsentry/sentry-go/internal/ratelimit/category.go @@ -94,9 +94,9 @@ func (c Category) GetPriority() Priority { case CategoryMonitor: return PriorityHigh case CategoryLog: - return PriorityMedium - case CategoryTransaction: return PriorityLow + case CategoryTransaction: + return PriorityMedium default: return PriorityMedium } diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go new file mode 100644 index 0000000..75e621e --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/bucketed_buffer.go @@ -0,0 +1,398 @@ +package telemetry + +import ( + "sync" + "sync/atomic" + "time" + + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +const ( + defaultBucketedCapacity = 100 + perBucketItemLimit = 100 +) + +type Bucket[T any] struct { + traceID string + items []T + createdAt time.Time + lastUpdatedAt time.Time +} + +// BucketedBuffer groups items by trace id, flushing per bucket. +type BucketedBuffer[T any] struct { + mu sync.RWMutex + + buckets []*Bucket[T] + traceIndex map[string]int + + head int + tail int + + itemCapacity int + bucketCapacity int + + totalItems int + bucketCount int + + category ratelimit.Category + priority ratelimit.Priority + overflowPolicy OverflowPolicy + batchSize int + timeout time.Duration + lastFlushTime time.Time + + offered int64 + dropped int64 + onDropped func(item T, reason string) +} + +func NewBucketedBuffer[T any]( + category ratelimit.Category, + capacity int, + overflowPolicy OverflowPolicy, + batchSize int, + timeout time.Duration, +) *BucketedBuffer[T] { + if capacity <= 0 { + capacity = defaultBucketedCapacity + } + if batchSize <= 0 { + batchSize = 1 + } + if timeout < 0 { + timeout = 0 + } + + bucketCapacity := capacity / 10 + if bucketCapacity < 10 { + bucketCapacity = 10 + } + + return &BucketedBuffer[T]{ + buckets: make([]*Bucket[T], bucketCapacity), + traceIndex: make(map[string]int), + itemCapacity: capacity, + bucketCapacity: bucketCapacity, + category: category, + priority: category.GetPriority(), + overflowPolicy: overflowPolicy, + batchSize: batchSize, + timeout: timeout, + lastFlushTime: time.Now(), + } +} + +func (b *BucketedBuffer[T]) Offer(item T) bool { + atomic.AddInt64(&b.offered, 1) + + traceID := "" + if ta, ok := any(item).(TraceAware); ok { + if tid, hasTrace := ta.GetTraceID(); hasTrace { + traceID = tid + } + } + + b.mu.Lock() + defer b.mu.Unlock() + return b.offerToBucket(item, traceID) +} + +func (b *BucketedBuffer[T]) offerToBucket(item T, traceID string) bool { + if traceID != "" { + if idx, exists := b.traceIndex[traceID]; exists { + bucket := b.buckets[idx] + if len(bucket.items) >= perBucketItemLimit { + delete(b.traceIndex, traceID) + } else { + bucket.items = append(bucket.items, item) + bucket.lastUpdatedAt = time.Now() + b.totalItems++ + return true + } + } + } + + if b.totalItems >= b.itemCapacity { + return b.handleOverflow(item, traceID) + } + if b.bucketCount >= b.bucketCapacity { + return b.handleOverflow(item, traceID) + } + + bucket := &Bucket[T]{ + traceID: traceID, + items: []T{item}, + createdAt: time.Now(), + lastUpdatedAt: time.Now(), + } + b.buckets[b.tail] = bucket + if traceID != "" { + b.traceIndex[traceID] = b.tail + } + b.tail = (b.tail + 1) % b.bucketCapacity + b.bucketCount++ + b.totalItems++ + return true +} + +func (b *BucketedBuffer[T]) handleOverflow(item T, traceID string) bool { + switch b.overflowPolicy { + case OverflowPolicyDropOldest: + oldestBucket := b.buckets[b.head] + if oldestBucket == nil { + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(item, "buffer_full_invalid_state") + } + return false + } + if oldestBucket.traceID != "" { + delete(b.traceIndex, oldestBucket.traceID) + } + droppedCount := len(oldestBucket.items) + atomic.AddInt64(&b.dropped, int64(droppedCount)) + if b.onDropped != nil { + for _, di := range oldestBucket.items { + b.onDropped(di, "buffer_full_drop_oldest_bucket") + } + } + b.totalItems -= droppedCount + b.bucketCount-- + b.head = (b.head + 1) % b.bucketCapacity + // add new bucket + bucket := &Bucket[T]{traceID: traceID, items: []T{item}, createdAt: time.Now(), lastUpdatedAt: time.Now()} + b.buckets[b.tail] = bucket + if traceID != "" { + b.traceIndex[traceID] = b.tail + } + b.tail = (b.tail + 1) % b.bucketCapacity + b.bucketCount++ + b.totalItems++ + return true + case OverflowPolicyDropNewest: + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(item, "buffer_full_drop_newest") + } + return false + default: + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(item, "unknown_overflow_policy") + } + return false + } +} + +func (b *BucketedBuffer[T]) Poll() (T, bool) { + b.mu.Lock() + defer b.mu.Unlock() + var zero T + if b.bucketCount == 0 { + return zero, false + } + bucket := b.buckets[b.head] + if bucket == nil || len(bucket.items) == 0 { + return zero, false + } + item := bucket.items[0] + bucket.items = bucket.items[1:] + b.totalItems-- + if len(bucket.items) == 0 { + if bucket.traceID != "" { + delete(b.traceIndex, bucket.traceID) + } + b.buckets[b.head] = nil + b.head = (b.head + 1) % b.bucketCapacity + b.bucketCount-- + } + return item, true +} + +func (b *BucketedBuffer[T]) PollBatch(maxItems int) []T { + if maxItems <= 0 { + return nil + } + b.mu.Lock() + defer b.mu.Unlock() + if b.bucketCount == 0 { + return nil + } + res := make([]T, 0, maxItems) + for len(res) < maxItems && b.bucketCount > 0 { + bucket := b.buckets[b.head] + if bucket == nil { + break + } + n := maxItems - len(res) + if n > len(bucket.items) { + n = len(bucket.items) + } + res = append(res, bucket.items[:n]...) + bucket.items = bucket.items[n:] + b.totalItems -= n + if len(bucket.items) == 0 { + if bucket.traceID != "" { + delete(b.traceIndex, bucket.traceID) + } + b.buckets[b.head] = nil + b.head = (b.head + 1) % b.bucketCapacity + b.bucketCount-- + } + } + return res +} + +func (b *BucketedBuffer[T]) PollIfReady() []T { + b.mu.Lock() + defer b.mu.Unlock() + if b.bucketCount == 0 { + return nil + } + ready := b.totalItems >= b.batchSize || (b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout) + if !ready { + return nil + } + oldest := b.buckets[b.head] + if oldest == nil { + return nil + } + items := oldest.items + if oldest.traceID != "" { + delete(b.traceIndex, oldest.traceID) + } + b.buckets[b.head] = nil + b.head = (b.head + 1) % b.bucketCapacity + b.totalItems -= len(items) + b.bucketCount-- + b.lastFlushTime = time.Now() + return items +} + +func (b *BucketedBuffer[T]) Drain() []T { + b.mu.Lock() + defer b.mu.Unlock() + if b.bucketCount == 0 { + return nil + } + res := make([]T, 0, b.totalItems) + for i := 0; i < b.bucketCount; i++ { + idx := (b.head + i) % b.bucketCapacity + bucket := b.buckets[idx] + if bucket != nil { + res = append(res, bucket.items...) + b.buckets[idx] = nil + } + } + b.traceIndex = make(map[string]int) + b.head = 0 + b.tail = 0 + b.totalItems = 0 + b.bucketCount = 0 + return res +} + +func (b *BucketedBuffer[T]) Peek() (T, bool) { + b.mu.RLock() + defer b.mu.RUnlock() + var zero T + if b.bucketCount == 0 { + return zero, false + } + bucket := b.buckets[b.head] + if bucket == nil || len(bucket.items) == 0 { + return zero, false + } + return bucket.items[0], true +} + +func (b *BucketedBuffer[T]) Size() int { b.mu.RLock(); defer b.mu.RUnlock(); return b.totalItems } +func (b *BucketedBuffer[T]) Capacity() int { b.mu.RLock(); defer b.mu.RUnlock(); return b.itemCapacity } +func (b *BucketedBuffer[T]) Category() ratelimit.Category { + b.mu.RLock() + defer b.mu.RUnlock() + return b.category +} +func (b *BucketedBuffer[T]) Priority() ratelimit.Priority { + b.mu.RLock() + defer b.mu.RUnlock() + return b.priority +} +func (b *BucketedBuffer[T]) IsEmpty() bool { + b.mu.RLock() + defer b.mu.RUnlock() + return b.bucketCount == 0 +} +func (b *BucketedBuffer[T]) IsFull() bool { + b.mu.RLock() + defer b.mu.RUnlock() + return b.totalItems >= b.itemCapacity +} +func (b *BucketedBuffer[T]) Utilization() float64 { + b.mu.RLock() + defer b.mu.RUnlock() + if b.itemCapacity == 0 { + return 0 + } + return float64(b.totalItems) / float64(b.itemCapacity) +} +func (b *BucketedBuffer[T]) OfferedCount() int64 { return atomic.LoadInt64(&b.offered) } +func (b *BucketedBuffer[T]) DroppedCount() int64 { return atomic.LoadInt64(&b.dropped) } +func (b *BucketedBuffer[T]) AcceptedCount() int64 { return b.OfferedCount() - b.DroppedCount() } +func (b *BucketedBuffer[T]) DropRate() float64 { + off := b.OfferedCount() + if off == 0 { + return 0 + } + return float64(b.DroppedCount()) / float64(off) +} + +func (b *BucketedBuffer[T]) GetMetrics() BufferMetrics { + b.mu.RLock() + size := b.totalItems + util := 0.0 + if b.itemCapacity > 0 { + util = float64(b.totalItems) / float64(b.itemCapacity) + } + b.mu.RUnlock() + return BufferMetrics{Category: b.category, Priority: b.priority, Capacity: b.itemCapacity, Size: size, Utilization: util, OfferedCount: b.OfferedCount(), DroppedCount: b.DroppedCount(), AcceptedCount: b.AcceptedCount(), DropRate: b.DropRate(), LastUpdated: time.Now()} +} + +func (b *BucketedBuffer[T]) SetDroppedCallback(callback func(item T, reason string)) { + b.mu.Lock() + defer b.mu.Unlock() + b.onDropped = callback +} +func (b *BucketedBuffer[T]) Clear() { + b.mu.Lock() + defer b.mu.Unlock() + for i := 0; i < b.bucketCapacity; i++ { + b.buckets[i] = nil + } + b.traceIndex = make(map[string]int) + b.head = 0 + b.tail = 0 + b.totalItems = 0 + b.bucketCount = 0 +} +func (b *BucketedBuffer[T]) IsReadyToFlush() bool { + b.mu.RLock() + defer b.mu.RUnlock() + if b.bucketCount == 0 { + return false + } + if b.totalItems >= b.batchSize { + return true + } + if b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout { + return true + } + return false +} +func (b *BucketedBuffer[T]) MarkFlushed() { + b.mu.Lock() + defer b.mu.Unlock() + b.lastFlushTime = time.Now() +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go new file mode 100644 index 0000000..7305d1f --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer.go @@ -0,0 +1,378 @@ +package telemetry + +import ( + "sync" + "sync/atomic" + "time" + + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +const defaultCapacity = 100 + +// RingBuffer is a thread-safe ring buffer with overflow policies. +type RingBuffer[T any] struct { + mu sync.RWMutex + items []T + head int + tail int + size int + capacity int + + category ratelimit.Category + priority ratelimit.Priority + overflowPolicy OverflowPolicy + + batchSize int + timeout time.Duration + lastFlushTime time.Time + + offered int64 + dropped int64 + onDropped func(item T, reason string) +} + +func NewRingBuffer[T any](category ratelimit.Category, capacity int, overflowPolicy OverflowPolicy, batchSize int, timeout time.Duration) *RingBuffer[T] { + if capacity <= 0 { + capacity = defaultCapacity + } + + if batchSize <= 0 { + batchSize = 1 + } + + if timeout < 0 { + timeout = 0 + } + + return &RingBuffer[T]{ + items: make([]T, capacity), + capacity: capacity, + category: category, + priority: category.GetPriority(), + overflowPolicy: overflowPolicy, + batchSize: batchSize, + timeout: timeout, + lastFlushTime: time.Now(), + } +} + +func (b *RingBuffer[T]) SetDroppedCallback(callback func(item T, reason string)) { + b.mu.Lock() + defer b.mu.Unlock() + b.onDropped = callback +} + +func (b *RingBuffer[T]) Offer(item T) bool { + atomic.AddInt64(&b.offered, 1) + + b.mu.Lock() + defer b.mu.Unlock() + + if b.size < b.capacity { + b.items[b.tail] = item + b.tail = (b.tail + 1) % b.capacity + b.size++ + return true + } + + switch b.overflowPolicy { + case OverflowPolicyDropOldest: + oldItem := b.items[b.head] + b.items[b.head] = item + b.head = (b.head + 1) % b.capacity + b.tail = (b.tail + 1) % b.capacity + + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(oldItem, "buffer_full_drop_oldest") + } + return true + + case OverflowPolicyDropNewest: + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(item, "buffer_full_drop_newest") + } + return false + + default: + atomic.AddInt64(&b.dropped, 1) + if b.onDropped != nil { + b.onDropped(item, "unknown_overflow_policy") + } + return false + } +} + +func (b *RingBuffer[T]) Poll() (T, bool) { + b.mu.Lock() + defer b.mu.Unlock() + + var zero T + if b.size == 0 { + return zero, false + } + + item := b.items[b.head] + b.items[b.head] = zero + b.head = (b.head + 1) % b.capacity + b.size-- + + return item, true +} + +func (b *RingBuffer[T]) PollBatch(maxItems int) []T { + if maxItems <= 0 { + return nil + } + + b.mu.Lock() + defer b.mu.Unlock() + + if b.size == 0 { + return nil + } + + itemCount := maxItems + if itemCount > b.size { + itemCount = b.size + } + + result := make([]T, itemCount) + var zero T + + for i := 0; i < itemCount; i++ { + result[i] = b.items[b.head] + b.items[b.head] = zero + b.head = (b.head + 1) % b.capacity + b.size-- + } + + return result +} + +func (b *RingBuffer[T]) Drain() []T { + b.mu.Lock() + defer b.mu.Unlock() + + if b.size == 0 { + return nil + } + + result := make([]T, b.size) + index := 0 + var zero T + + for i := 0; i < b.size; i++ { + pos := (b.head + i) % b.capacity + result[index] = b.items[pos] + b.items[pos] = zero + index++ + } + + b.head = 0 + b.tail = 0 + b.size = 0 + + return result +} + +func (b *RingBuffer[T]) Peek() (T, bool) { + b.mu.RLock() + defer b.mu.RUnlock() + + var zero T + if b.size == 0 { + return zero, false + } + + return b.items[b.head], true +} + +func (b *RingBuffer[T]) Size() int { + b.mu.RLock() + defer b.mu.RUnlock() + return b.size +} + +func (b *RingBuffer[T]) Capacity() int { + b.mu.RLock() + defer b.mu.RUnlock() + return b.capacity +} + +func (b *RingBuffer[T]) Category() ratelimit.Category { + b.mu.RLock() + defer b.mu.RUnlock() + return b.category +} + +func (b *RingBuffer[T]) Priority() ratelimit.Priority { + b.mu.RLock() + defer b.mu.RUnlock() + return b.priority +} + +func (b *RingBuffer[T]) IsEmpty() bool { + b.mu.RLock() + defer b.mu.RUnlock() + return b.size == 0 +} + +func (b *RingBuffer[T]) IsFull() bool { + b.mu.RLock() + defer b.mu.RUnlock() + return b.size == b.capacity +} + +func (b *RingBuffer[T]) Utilization() float64 { + b.mu.RLock() + defer b.mu.RUnlock() + return float64(b.size) / float64(b.capacity) +} + +func (b *RingBuffer[T]) OfferedCount() int64 { + return atomic.LoadInt64(&b.offered) +} + +func (b *RingBuffer[T]) DroppedCount() int64 { + return atomic.LoadInt64(&b.dropped) +} + +func (b *RingBuffer[T]) AcceptedCount() int64 { + return b.OfferedCount() - b.DroppedCount() +} + +func (b *RingBuffer[T]) DropRate() float64 { + offered := b.OfferedCount() + if offered == 0 { + return 0.0 + } + return float64(b.DroppedCount()) / float64(offered) +} + +func (b *RingBuffer[T]) Clear() { + b.mu.Lock() + defer b.mu.Unlock() + + var zero T + for i := 0; i < b.capacity; i++ { + b.items[i] = zero + } + + b.head = 0 + b.tail = 0 + b.size = 0 +} + +func (b *RingBuffer[T]) GetMetrics() BufferMetrics { + b.mu.RLock() + size := b.size + util := float64(b.size) / float64(b.capacity) + b.mu.RUnlock() + + return BufferMetrics{ + Category: b.category, + Priority: b.priority, + Capacity: b.capacity, + Size: size, + Utilization: util, + OfferedCount: b.OfferedCount(), + DroppedCount: b.DroppedCount(), + AcceptedCount: b.AcceptedCount(), + DropRate: b.DropRate(), + LastUpdated: time.Now(), + } +} + +func (b *RingBuffer[T]) IsReadyToFlush() bool { + b.mu.RLock() + defer b.mu.RUnlock() + + if b.size == 0 { + return false + } + + if b.size >= b.batchSize { + return true + } + + if b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout { + return true + } + + return false +} + +func (b *RingBuffer[T]) MarkFlushed() { + b.mu.Lock() + defer b.mu.Unlock() + b.lastFlushTime = time.Now() +} + +func (b *RingBuffer[T]) PollIfReady() []T { + b.mu.Lock() + defer b.mu.Unlock() + + if b.size == 0 { + return nil + } + + ready := b.size >= b.batchSize || + (b.timeout > 0 && time.Since(b.lastFlushTime) >= b.timeout) + + if !ready { + return nil + } + + itemCount := b.batchSize + if itemCount > b.size { + itemCount = b.size + } + + result := make([]T, itemCount) + var zero T + + for i := 0; i < itemCount; i++ { + result[i] = b.items[b.head] + b.items[b.head] = zero + b.head = (b.head + 1) % b.capacity + b.size-- + } + + b.lastFlushTime = time.Now() + return result +} + +type BufferMetrics struct { + Category ratelimit.Category `json:"category"` + Priority ratelimit.Priority `json:"priority"` + Capacity int `json:"capacity"` + Size int `json:"size"` + Utilization float64 `json:"utilization"` + OfferedCount int64 `json:"offered_count"` + DroppedCount int64 `json:"dropped_count"` + AcceptedCount int64 `json:"accepted_count"` + DropRate float64 `json:"drop_rate"` + LastUpdated time.Time `json:"last_updated"` +} + +// OverflowPolicy defines how the ring buffer handles overflow. +type OverflowPolicy int + +const ( + OverflowPolicyDropOldest OverflowPolicy = iota + OverflowPolicyDropNewest +) + +func (op OverflowPolicy) String() string { + switch op { + case OverflowPolicyDropOldest: + return "drop_oldest" + case OverflowPolicyDropNewest: + return "drop_newest" + default: + return "unknown" + } +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer_wrapper.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer_wrapper.go new file mode 100644 index 0000000..a5e6e39 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/buffer_wrapper.go @@ -0,0 +1,49 @@ +package telemetry + +import ( + "context" + "time" + + "github.com/getsentry/sentry-go/internal/protocol" + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +// Buffer is the top-level buffer that wraps the scheduler and category buffers. +type Buffer struct { + scheduler *Scheduler +} + +// NewBuffer creates a new Buffer with the given configuration. +func NewBuffer( + storage map[ratelimit.Category]Storage[protocol.EnvelopeItemConvertible], + transport protocol.TelemetryTransport, + dsn *protocol.Dsn, + sdkInfo *protocol.SdkInfo, +) *Buffer { + scheduler := NewScheduler(storage, transport, dsn, sdkInfo) + scheduler.Start() + + return &Buffer{ + scheduler: scheduler, + } +} + +// Add adds an EnvelopeItemConvertible to the appropriate buffer based on its category. +func (b *Buffer) Add(item protocol.EnvelopeItemConvertible) bool { + return b.scheduler.Add(item) +} + +// Flush forces all buffers to flush within the given timeout. +func (b *Buffer) Flush(timeout time.Duration) bool { + return b.scheduler.Flush(timeout) +} + +// FlushWithContext flushes with a custom context for cancellation. +func (b *Buffer) FlushWithContext(ctx context.Context) bool { + return b.scheduler.FlushWithContext(ctx) +} + +// Close stops the buffer, flushes remaining data, and releases resources. +func (b *Buffer) Close(timeout time.Duration) { + b.scheduler.Stop(timeout) +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go new file mode 100644 index 0000000..940fc91 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/scheduler.go @@ -0,0 +1,279 @@ +package telemetry + +import ( + "context" + "sync" + "time" + + "github.com/getsentry/sentry-go/internal/debuglog" + "github.com/getsentry/sentry-go/internal/protocol" + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +// Scheduler implements a weighted round-robin scheduler for processing buffered events. +type Scheduler struct { + buffers map[ratelimit.Category]Storage[protocol.EnvelopeItemConvertible] + transport protocol.TelemetryTransport + dsn *protocol.Dsn + sdkInfo *protocol.SdkInfo + + currentCycle []ratelimit.Priority + cyclePos int + + ctx context.Context + cancel context.CancelFunc + processingWg sync.WaitGroup + + mu sync.Mutex + cond *sync.Cond + startOnce sync.Once + finishOnce sync.Once +} + +func NewScheduler( + buffers map[ratelimit.Category]Storage[protocol.EnvelopeItemConvertible], + transport protocol.TelemetryTransport, + dsn *protocol.Dsn, + sdkInfo *protocol.SdkInfo, +) *Scheduler { + ctx, cancel := context.WithCancel(context.Background()) + + priorityWeights := map[ratelimit.Priority]int{ + ratelimit.PriorityCritical: 5, + ratelimit.PriorityHigh: 4, + ratelimit.PriorityMedium: 3, + ratelimit.PriorityLow: 2, + ratelimit.PriorityLowest: 1, + } + + var currentCycle []ratelimit.Priority + for priority, weight := range priorityWeights { + hasBuffers := false + for _, buffer := range buffers { + if buffer.Priority() == priority { + hasBuffers = true + break + } + } + + if hasBuffers { + for i := 0; i < weight; i++ { + currentCycle = append(currentCycle, priority) + } + } + } + + s := &Scheduler{ + buffers: buffers, + transport: transport, + dsn: dsn, + sdkInfo: sdkInfo, + currentCycle: currentCycle, + ctx: ctx, + cancel: cancel, + } + s.cond = sync.NewCond(&s.mu) + + return s +} + +func (s *Scheduler) Start() { + s.startOnce.Do(func() { + s.processingWg.Add(1) + go s.run() + }) +} + +func (s *Scheduler) Stop(timeout time.Duration) { + s.finishOnce.Do(func() { + s.Flush(timeout) + + s.cancel() + s.cond.Broadcast() + + done := make(chan struct{}) + go func() { + defer close(done) + s.processingWg.Wait() + }() + + select { + case <-done: + case <-time.After(timeout): + debuglog.Printf("scheduler stop timed out after %v", timeout) + } + }) +} + +func (s *Scheduler) Signal() { + s.cond.Signal() +} + +func (s *Scheduler) Add(item protocol.EnvelopeItemConvertible) bool { + category := item.GetCategory() + buffer, exists := s.buffers[category] + if !exists { + return false + } + + accepted := buffer.Offer(item) + if accepted { + s.Signal() + } + return accepted +} + +func (s *Scheduler) Flush(timeout time.Duration) bool { + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + return s.FlushWithContext(ctx) +} + +func (s *Scheduler) FlushWithContext(ctx context.Context) bool { + s.flushBuffers() + return s.transport.FlushWithContext(ctx) +} + +func (s *Scheduler) run() { + defer s.processingWg.Done() + + go func() { + ticker := time.NewTicker(100 * time.Millisecond) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + s.cond.Broadcast() + case <-s.ctx.Done(): + return + } + } + }() + + for { + s.mu.Lock() + + for !s.hasWork() && s.ctx.Err() == nil { + s.cond.Wait() + } + + if s.ctx.Err() != nil { + s.mu.Unlock() + return + } + + s.mu.Unlock() + s.processNextBatch() + } +} + +func (s *Scheduler) hasWork() bool { + for _, buffer := range s.buffers { + if buffer.IsReadyToFlush() { + return true + } + } + return false +} + +func (s *Scheduler) processNextBatch() { + if len(s.currentCycle) == 0 { + return + } + + priority := s.currentCycle[s.cyclePos] + s.cyclePos = (s.cyclePos + 1) % len(s.currentCycle) + + var bufferToProcess Storage[protocol.EnvelopeItemConvertible] + var categoryToProcess ratelimit.Category + for category, buffer := range s.buffers { + if buffer.Priority() == priority && buffer.IsReadyToFlush() { + bufferToProcess = buffer + categoryToProcess = category + break + } + } + + if bufferToProcess != nil { + s.processItems(bufferToProcess, categoryToProcess, false) + } +} + +func (s *Scheduler) processItems(buffer Storage[protocol.EnvelopeItemConvertible], category ratelimit.Category, force bool) { + var items []protocol.EnvelopeItemConvertible + + if force { + items = buffer.Drain() + } else { + items = buffer.PollIfReady() + } + + // drop the current batch if rate-limited or if transport is full + if len(items) == 0 || s.isRateLimited(category) || !s.transport.HasCapacity() { + return + } + + switch category { + case ratelimit.CategoryLog: + logs := protocol.Logs(items) + header := &protocol.EnvelopeHeader{EventID: protocol.GenerateEventID(), SentAt: time.Now(), Sdk: s.sdkInfo} + if s.dsn != nil { + header.Dsn = s.dsn.String() + } + envelope := protocol.NewEnvelope(header) + item, err := logs.ToEnvelopeItem() + if err != nil { + debuglog.Printf("error creating log batch envelope item: %v", err) + return + } + envelope.AddItem(item) + if err := s.transport.SendEnvelope(envelope); err != nil { + debuglog.Printf("error sending envelope: %v", err) + } + return + default: + // if the buffers are properly configured, buffer.PollIfReady should return a single item for every category + // other than logs. We still iterate over the items just in case, because we don't want to send broken envelopes. + for _, it := range items { + s.sendItem(it) + } + } +} + +func (s *Scheduler) sendItem(item protocol.EnvelopeItemConvertible) { + header := &protocol.EnvelopeHeader{ + EventID: item.GetEventID(), + SentAt: time.Now(), + Trace: item.GetDynamicSamplingContext(), + Sdk: s.sdkInfo, + } + if header.EventID == "" { + header.EventID = protocol.GenerateEventID() + } + if s.dsn != nil { + header.Dsn = s.dsn.String() + } + envelope := protocol.NewEnvelope(header) + envItem, err := item.ToEnvelopeItem() + if err != nil { + debuglog.Printf("error while converting to envelope item: %v", err) + return + } + envelope.AddItem(envItem) + if err := s.transport.SendEnvelope(envelope); err != nil { + debuglog.Printf("error sending envelope: %v", err) + } +} + +func (s *Scheduler) flushBuffers() { + for category, buffer := range s.buffers { + if !buffer.IsEmpty() { + s.processItems(buffer, category, true) + } + } +} + +func (s *Scheduler) isRateLimited(category ratelimit.Category) bool { + return s.transport.IsRateLimited(category) +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/storage.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/storage.go new file mode 100644 index 0000000..5621e33 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/storage.go @@ -0,0 +1,42 @@ +package telemetry + +import ( + "github.com/getsentry/sentry-go/internal/ratelimit" +) + +// Storage defines the common interface for all buffer storage implementations. +type Storage[T any] interface { + // Core operations + Offer(item T) bool + Poll() (T, bool) + PollBatch(maxItems int) []T + PollIfReady() []T + Drain() []T + Peek() (T, bool) + + // State queries + Size() int + Capacity() int + IsEmpty() bool + IsFull() bool + Utilization() float64 + + // Flush management + IsReadyToFlush() bool + MarkFlushed() + + // Category/Priority + Category() ratelimit.Category + Priority() ratelimit.Priority + + // Metrics + OfferedCount() int64 + DroppedCount() int64 + AcceptedCount() int64 + DropRate() float64 + GetMetrics() BufferMetrics + + // Configuration + SetDroppedCallback(callback func(item T, reason string)) + Clear() +} diff --git a/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go b/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go new file mode 100644 index 0000000..a321033 --- /dev/null +++ b/vendor/github.com/getsentry/sentry-go/internal/telemetry/trace_aware.go @@ -0,0 +1,7 @@ +package telemetry + +// TraceAware is implemented by items that can expose a trace ID. +// BucketedBuffer uses this to group items by trace. +type TraceAware interface { + GetTraceID() (string, bool) +} diff --git a/vendor/github.com/getsentry/sentry-go/log.go b/vendor/github.com/getsentry/sentry-go/log.go index 58e52f7..b234739 100644 --- a/vendor/github.com/getsentry/sentry-go/log.go +++ b/vendor/github.com/getsentry/sentry-go/log.go @@ -66,7 +66,7 @@ func NewLogger(ctx context.Context) Logger { } client := hub.Client() - if client != nil && client.batchLogger != nil { + if client != nil && client.options.EnableLogs { return &sentryLogger{ ctx: ctx, client: client, @@ -76,11 +76,10 @@ func NewLogger(ctx context.Context) Logger { } debuglog.Println("fallback to noopLogger: enableLogs disabled") - return &noopLogger{} // fallback: does nothing + return &noopLogger{} } func (l *sentryLogger) Write(p []byte) (int, error) { - // Avoid sending double newlines to Sentry msg := strings.TrimRight(string(p), "\n") l.Info().Emit(msg) return len(p), nil @@ -145,8 +144,6 @@ func (l *sentryLogger) log(ctx context.Context, level LogLevel, severity int, me for k, v := range entryAttrs { attrs[k] = v } - - // Set default attributes if release := l.client.options.Release; release != "" { attrs["sentry.release"] = Attribute{Value: release, Type: AttributeString} } @@ -194,7 +191,13 @@ func (l *sentryLogger) log(ctx context.Context, level LogLevel, severity int, me } if log != nil { - l.client.batchLogger.logCh <- *log + if l.client.telemetryBuffer != nil { + if !l.client.telemetryBuffer.Add(log) { + debuglog.Print("Dropping event: log buffer full or category missing") + } + } else if l.client.batchLogger != nil { + l.client.batchLogger.logCh <- *log + } } if l.client.options.Debug { @@ -287,7 +290,7 @@ func (l *sentryLogger) Panic() LogEntry { level: LogLevelFatal, severity: LogSeverityFatal, attributes: make(map[string]Attribute), - shouldPanic: true, // this should panic instead of exit + shouldPanic: true, } } diff --git a/vendor/github.com/getsentry/sentry-go/sentry.go b/vendor/github.com/getsentry/sentry-go/sentry.go index b349944..4193bcd 100644 --- a/vendor/github.com/getsentry/sentry-go/sentry.go +++ b/vendor/github.com/getsentry/sentry-go/sentry.go @@ -6,7 +6,7 @@ import ( ) // The version of the SDK. -const SDKVersion = "0.36.2" +const SDKVersion = "0.40.0" // apiVersion is the minimum version of the Sentry API compatible with the // sentry-go SDK. diff --git a/vendor/github.com/getsentry/sentry-go/transport.go b/vendor/github.com/getsentry/sentry-go/transport.go index d57e155..487e54c 100644 --- a/vendor/github.com/getsentry/sentry-go/transport.go +++ b/vendor/github.com/getsentry/sentry-go/transport.go @@ -788,7 +788,29 @@ func (a *internalAsyncTransportAdapter) Configure(options ClientOptions) { } func (a *internalAsyncTransportAdapter) SendEvent(event *Event) { - a.transport.SendEvent(event) + header := &protocol.EnvelopeHeader{EventID: string(event.EventID), SentAt: time.Now(), Sdk: &protocol.SdkInfo{Name: event.Sdk.Name, Version: event.Sdk.Version}} + if a.dsn != nil { + header.Dsn = a.dsn.String() + } + if header.EventID == "" { + header.EventID = protocol.GenerateEventID() + } + envelope := protocol.NewEnvelope(header) + item, err := event.ToEnvelopeItem() + if err != nil { + debuglog.Printf("Failed to convert event to envelope item: %v", err) + return + } + envelope.AddItem(item) + + for _, attachment := range event.Attachments { + attachmentItem := protocol.NewAttachmentItem(attachment.Filename, attachment.ContentType, attachment.Payload) + envelope.AddItem(attachmentItem) + } + + if err := a.transport.SendEnvelope(envelope); err != nil { + debuglog.Printf("Error sending envelope: %v", err) + } } func (a *internalAsyncTransportAdapter) Flush(timeout time.Duration) bool { diff --git a/vendor/github.com/getsentry/sentry-go/util.go b/vendor/github.com/getsentry/sentry-go/util.go index 3a6a33c..5452430 100644 --- a/vendor/github.com/getsentry/sentry-go/util.go +++ b/vendor/github.com/getsentry/sentry-go/util.go @@ -1,8 +1,6 @@ package sentry import ( - "crypto/rand" - "encoding/hex" "encoding/json" "fmt" "os" @@ -11,18 +9,12 @@ import ( "time" "github.com/getsentry/sentry-go/internal/debuglog" + "github.com/getsentry/sentry-go/internal/protocol" exec "golang.org/x/sys/execabs" ) func uuid() string { - id := make([]byte, 16) - // Prefer rand.Read over rand.Reader, see https://go-review.googlesource.com/c/go/+/272326/. - _, _ = rand.Read(id) - id[6] &= 0x0F // clear version - id[6] |= 0x40 // set version to 4 (random uuid) - id[8] &= 0x3F // clear variant - id[8] |= 0x80 // set to IETF variant - return hex.EncodeToString(id) + return protocol.GenerateEventID() } func fileExists(fileName string) bool { diff --git a/vendor/github.com/olekukonko/ll/global.go b/vendor/github.com/olekukonko/ll/global.go index f4a8489..85146f5 100644 --- a/vendor/github.com/olekukonko/ll/global.go +++ b/vendor/github.com/olekukonko/ll/global.go @@ -657,6 +657,13 @@ func Mark(names ...string) { // It is similar to Dbg but formats the output as JSON for better readability. It is thread-safe and respects // the logger’s configuration (e.g., enabled, level, suspend, handler, middleware). func Output(values ...interface{}) { + defaultLogger.output(2, values...) + +} + +// Inspect logs one or more values in a **developer-friendly, deeply introspective format** at Info level. +// It includes the caller file and line number, and reveals **all fields** — including: +func Inspect(values ...interface{}) { o := NewInspector(defaultLogger) o.Log(2, values...) } diff --git a/vendor/github.com/olekukonko/ll/inspector.go b/vendor/github.com/olekukonko/ll/inspector.go index f4e0fa5..fb6d690 100644 --- a/vendor/github.com/olekukonko/ll/inspector.go +++ b/vendor/github.com/olekukonko/ll/inspector.go @@ -79,7 +79,7 @@ func (o *Inspector) Log(skip int, values ...interface{}) { } // Construct log message with file, line, and JSON data - msg := fmt.Sprintf("[%s:%d] DUMP: %s", shortFile, line, string(jsonData)) + msg := fmt.Sprintf("[%s:%d] INSPECT: %s", shortFile, line, string(jsonData)) o.logger.log(lx.LevelInfo, lx.ClassText, msg, nil, false) } } diff --git a/vendor/github.com/olekukonko/ll/ll.go b/vendor/github.com/olekukonko/ll/ll.go index 04d2008..7510b89 100644 --- a/vendor/github.com/olekukonko/ll/ll.go +++ b/vendor/github.com/olekukonko/ll/ll.go @@ -350,17 +350,58 @@ func (l *Logger) Dump(values ...interface{}) { } } -// Output logs data in a human-readable JSON format at Info level, including caller file and line information. -// It is similar to Dbg but formats the output as JSON for better readability. It is thread-safe and respects -// the logger's configuration (e.g., enabled, level, suspend, handler, middleware). -// Example: -// -// logger := New("app").Enable() -// x := map[string]int{"key": 42} -// logger.Output(x) // Output: [app] INFO: [file.go:123] JSON: {"key": 42} -// -// Logger method to provide access to Output functionality +// Output logs each value as pretty-printed JSON for REST debugging. +// Each value is logged on its own line with [file:line] and a blank line after the header. +// Ideal for inspecting outgoing/incoming REST payloads. func (l *Logger) Output(values ...interface{}) { + l.output(2, values...) +} + +func (l *Logger) output(skip int, values ...interface{}) { + if !l.shouldLog(lx.LevelInfo) { + return + } + + _, file, line, ok := runtime.Caller(skip) + if !ok { + return + } + shortFile := file + if idx := strings.LastIndex(file, "/"); idx >= 0 { + shortFile = file[idx+1:] + } + + header := fmt.Sprintf("[%s:%d] JSON:\n", shortFile, line) + + for _, v := range values { + // Always pretty-print with indent + b, err := json.MarshalIndent(v, " ", " ") + if err != nil { + b, _ = json.MarshalIndent(map[string]any{ + "value": fmt.Sprintf("%+v", v), + "error": err.Error(), + }, " ", " ") + } + l.log(lx.LevelInfo, lx.ClassText, header+string(b), nil, false) + } +} + +// Inspect logs one or more values in a **developer-friendly, deeply introspective format** at Info level. +// It includes the caller file and line number, and reveals **all fields** — including: +// +// - Private (unexported) fields → prefixed with `(field)` +// - Embedded structs (inlined) +// - Pointers and nil values → shown as `*(field)` or `nil` +// - Full struct nesting and type information +// +// This method uses `NewInspector` under the hood, which performs **full reflection-based traversal**. +// It is **not** meant for production logging or REST APIs — use `Output` for that. +// +// Ideal for: +// - Debugging complex internal state +// - Inspecting structs with private fields +// - Understanding struct embedding and pointer behavior +func (l *Logger) Inspect(values ...interface{}) { o := NewInspector(l) o.Log(2, values...) } diff --git a/vendor/github.com/olekukonko/tablewriter/.gitignore b/vendor/github.com/olekukonko/tablewriter/.gitignore index f79a287..bb40e4c 100644 --- a/vendor/github.com/olekukonko/tablewriter/.gitignore +++ b/vendor/github.com/olekukonko/tablewriter/.gitignore @@ -8,3 +8,4 @@ dev.sh *csv2table _test/ +*.test diff --git a/vendor/github.com/olekukonko/tablewriter/MIGRATION.md b/vendor/github.com/olekukonko/tablewriter/MIGRATION.md index 650a195..08ab305 100644 --- a/vendor/github.com/olekukonko/tablewriter/MIGRATION.md +++ b/vendor/github.com/olekukonko/tablewriter/MIGRATION.md @@ -206,51 +206,51 @@ func main() { The `defaultConfig()` function (`config.go:defaultConfig`) establishes baseline settings for new tables, ensuring predictable behavior unless overridden. Below is a detailed table of default parameters, organized by configuration section, to help you understand the starting point for table behavior and appearance. -| Section | Parameter | Default Value | Description | -|---------------|-------------------------------|-----------------------------------|-----------------------------------------------------------------------------| -| **Header** | `Alignment.Global` | `tw.AlignCenter` | Centers header text globally unless overridden by `PerColumn`. | -| Header | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global` unless specified. | -| Header | `Formatting.AutoFormat` | `tw.On` | Applies title case (e.g., "col_one" → "COL ONE") to header content. | -| Header | `Formatting.AutoWrap` | `tw.WrapTruncate` | Truncates long header text with "…" based on width constraints. | -| Header | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in headers by default. | -| Header | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of header cells. | -| Header | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global` unless specified. | -| Header | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for header cells unless set. | -| Header | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits unless specified. | -| Header | `Filter.Global` | `nil` | No global content transformation for header cells. | -| Header | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations unless specified. | -| **Row** | `Alignment.Global` | `tw.AlignLeft` | Left-aligns row text globally unless overridden by `PerColumn`. | -| Row | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | -| Row | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting (e.g., title case) for row content. | -| Row | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long row text naturally at word boundaries based on width constraints.| -| Row | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in rows by default. | -| Row | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of row cells. | -| Row | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | -| Row | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for row cells. | -| Row | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | -| Row | `Filter.Global` | `nil` | No global content transformation for row cells. | -| Row | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | -| **Footer** | `Alignment.Global` | `tw.AlignRight` | Right-aligns footer text globally unless overridden by `PerColumn`. | -| Footer | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | -| Footer | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting for footer content. | -| Footer | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long footer text naturally. | -| Footer | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in footers. | -| Footer | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of footer cells. | -| Footer | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | -| Footer | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for footer cells. | -| Footer | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | -| Footer | `Filter.Global` | `nil` | No global content transformation for footer cells. | -| Footer | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | -| **Global** | `MaxWidth` | `0` (unlimited) | No overall table width limit. | -| Global | `Behavior.AutoHide` | `tw.Off` | Displays empty columns (ignored in streaming). | -| Global | `Behavior.TrimSpace` | `tw.On` | Trims leading/trailing spaces from cell content. | -| Global | `Behavior.Header` | `tw.Control{Hide: tw.Off}` | Shows header if content is provided. | -| Global | `Behavior.Footer` | `tw.Control{Hide: tw.Off}` | Shows footer if content is provided. | -| Global | `Behavior.Compact` | `tw.Compact{Merge: tw.Off}` | No compact width optimization for merged cells. | -| Global | `Debug` | `false` | Disables debug logging. | -| Global | `Stream.Enable` | `false` | Disables streaming mode by default. | -| Global | `Widths.Global` | `0` (unlimited) | No fixed column width unless specified. | -| Global | `Widths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column fixed widths unless specified. | +| Section | Parameter | Default Value | Description | +|---------------|--------------------------|-----------------------------------|-----------------------------------------------------------------------------| +| **Header** | `Alignment.Global` | `tw.AlignCenter` | Centers header text globally unless overridden by `PerColumn`. | +| Header | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global` unless specified. | +| Header | `Formatting.AutoFormat` | `tw.On` | Applies title case (e.g., "col_one" → "COL ONE") to header content. | +| Header | `Formatting.AutoWrap` | `tw.WrapTruncate` | Truncates long header text with "…" based on width constraints. | +| Header | `Merging.Mode` | `tw.MergeNone` | Disables cell merging in headers by default. | +| Header | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of header cells. | +| Header | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global` unless specified. | +| Header | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for header cells unless set. | +| Header | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits unless specified. | +| Header | `Filter.Global` | `nil` | No global content transformation for header cells. | +| Header | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations unless specified. | +| **Row** | `Alignment.Global` | `tw.AlignLeft` | Left-aligns row text globally unless overridden by `PerColumn`. | +| Row | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | +| Row | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting (e.g., title case) for row content. | +| Row | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long row text naturally at word boundaries based on width constraints.| +| Row | `Merging.Mode` | `tw.MergeNone` | Disables cell merging in rows by default. | +| Row | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of row cells. | +| Row | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | +| Row | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for row cells. | +| Row | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | +| Row | `Filter.Global` | `nil` | No global content transformation for row cells. | +| Row | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | +| **Footer** | `Alignment.Global` | `tw.AlignRight` | Right-aligns footer text globally unless overridden by `PerColumn`. | +| Footer | `Alignment.PerColumn` | `[]tw.Align{}` | Empty; falls back to `Global`. | +| Footer | `Formatting.AutoFormat` | `tw.Off` | Disables auto-formatting for footer content. | +| Footer | `Formatting.AutoWrap` | `tw.WrapNormal` | Wraps long footer text naturally. | +| Footer | `Formatting.MergeMode` | `tw.MergeNone` | Disables cell merging in footers. | +| Footer | `Padding.Global` | `tw.PaddingDefault` (`" "`) | Adds one space on left and right of footer cells. | +| Footer | `Padding.PerColumn` | `[]tw.Padding{}` | Empty; falls back to `Global`. | +| Footer | `ColMaxWidths.Global` | `0` (unlimited) | No maximum content width for footer cells. | +| Footer | `ColMaxWidths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column content width limits. | +| Footer | `Filter.Global` | `nil` | No global content transformation for footer cells. | +| Footer | `Filter.PerColumn` | `[]func(string) string{}` | No per-column content transformations. | +| **Global** | `MaxWidth` | `0` (unlimited) | No overall table width limit. | +| Global | `Behavior.AutoHide` | `tw.Off` | Displays empty columns (ignored in streaming). | +| Global | `Behavior.TrimSpace` | `tw.On` | Trims leading/trailing spaces from cell content. | +| Global | `Behavior.Header` | `tw.Control{Hide: tw.Off}` | Shows header if content is provided. | +| Global | `Behavior.Footer` | `tw.Control{Hide: tw.Off}` | Shows footer if content is provided. | +| Global | `Behavior.Compact` | `tw.Compact{Merge: tw.Off}` | No compact width optimization for merged cells. | +| Global | `Debug` | `false` | Disables debug logging. | +| Global | `Stream.Enable` | `false` | Disables streaming mode by default. | +| Global | `Widths.Global` | `0` (unlimited) | No fixed column width unless specified. | +| Global | `Widths.PerColumn` | `tw.NewMapper[int, int]()` | Empty map; no per-column fixed widths unless specified. | **Notes**: - Defaults can be overridden using any configuration method. @@ -2210,7 +2210,7 @@ import ( func main() { // Horizontal Merging (Similar to v0.0.5) tableH := tablewriter.NewTable(os.Stdout, - tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}}}), + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Merging: tw.CellMerging{Mode: tw.MergeHorizontal}}}), tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), // Specify renderer for symbols ) tableH.Header("Category", "Item", "Item", "Notes") // Note: Two "Item" headers for demo @@ -2219,7 +2219,7 @@ func main() { // Vertical Merging tableV := tablewriter.NewTable(os.Stdout, - tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeVertical}}}), + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Merging: tw.CellMerging{Mode: tw.MergeVertical}}}), tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), ) tableV.Header("User", "Permission") @@ -2230,7 +2230,7 @@ func main() { // Hierarchical Merging tableHier := tablewriter.NewTable(os.Stdout, - tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Formatting: tw.CellFormatting{MergeMode: tw.MergeHierarchical}}}), + tablewriter.WithConfig(tablewriter.Config{Row: tw.CellConfig{Merging: tw.CellMerging{Mode: tw.MergeHierarchical}}}), tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{Symbols: tw.NewSymbols(tw.StyleASCII)})), ) tableHier.Header("Group", "SubGroup", "Item") diff --git a/vendor/github.com/olekukonko/tablewriter/README.md b/vendor/github.com/olekukonko/tablewriter/README.md index 16d2882..3af9409 100644 --- a/vendor/github.com/olekukonko/tablewriter/README.md +++ b/vendor/github.com/olekukonko/tablewriter/README.md @@ -28,7 +28,7 @@ go get github.com/olekukonko/tablewriter@v0.0.5 #### Latest Version The latest stable version ```bash -go get github.com/olekukonko/tablewriter@v1.1.0 +go get github.com/olekukonko/tablewriter@v1.1.2 ``` **Warning:** Version `v1.0.0` contains missing functionality and should not be used. @@ -62,7 +62,7 @@ func main() { data := [][]string{ {"Package", "Version", "Status"}, {"tablewriter", "v0.0.5", "legacy"}, - {"tablewriter", "v1.1.0", "latest"}, + {"tablewriter", "v1.1.2", "latest"}, } table := tablewriter.NewWriter(os.Stdout) @@ -77,7 +77,7 @@ func main() { │ PACKAGE │ VERSION │ STATUS │ ├─────────────┼─────────┼────────┤ │ tablewriter │ v0.0.5 │ legacy │ -│ tablewriter │ v1.1.0 │ latest │ +│ tablewriter │ v1.1.2 │ latest │ └─────────────┴─────────┴────────┘ ``` @@ -520,7 +520,7 @@ func main() { tablewriter.WithConfig(tablewriter.Config{ Header: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignCenter}}, Row: tw.CellConfig{ - Formatting: tw.CellFormatting{MergeMode: tw.MergeHierarchical}, + Merging: tw.CellMerging{Mode: tw.MergeHierarchical}, Alignment: tw.CellAlignment{Global: tw.AlignLeft}, }, }), @@ -579,8 +579,8 @@ func main() { })), tablewriter.WithConfig(tablewriter.Config{ Row: tw.CellConfig{ - Formatting: tw.CellFormatting{MergeMode: tw.MergeBoth}, - Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}}, + Merging: tw.CellMerging{Mode: tw.MergeBoth}, + Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.Skip, tw.Skip, tw.AlignRight, tw.AlignLeft}}, }, Footer: tw.CellConfig{ @@ -806,12 +806,12 @@ func main() { tablewriter.WithRenderer(renderer.NewHTML(htmlCfg)), tablewriter.WithConfig(tablewriter.Config{ Header: tw.CellConfig{ - Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}, // Merge identical header cells - Alignment: tw.CellAlignment{Global: tw.AlignCenter}, + Merging: tw.CellMerging{Mode: tw.MergeHorizontal}, // Merge identical header cells + Alignment: tw.CellAlignment{Global: tw.AlignCenter}, }, Row: tw.CellConfig{ - Formatting: tw.CellFormatting{MergeMode: tw.MergeHorizontal}, // Merge identical row cells - Alignment: tw.CellAlignment{Global: tw.AlignLeft}, + Merging: tw.CellMerging{Mode: tw.MergeHorizontal}, // Merge identical row cells + Alignment: tw.CellAlignment{Global: tw.AlignLeft}, }, Footer: tw.CellConfig{Alignment: tw.CellAlignment{Global: tw.AlignRight}}, }), diff --git a/vendor/github.com/olekukonko/tablewriter/benchstat.txt b/vendor/github.com/olekukonko/tablewriter/benchstat.txt new file mode 100644 index 0000000..912c38d --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/benchstat.txt @@ -0,0 +1,194 @@ +goos: darwin +goarch: arm64 +pkg: github.com/olekukonko/tablewriter/pkg/twwarp +cpu: Apple M2 + │ old.txt │ new.txt │ + │ sec/op │ sec/op vs base │ +WrapString-8 112.8µ ± 1% 112.9µ ± 2% ~ (p=0.589 n=6) +WrapStringWithSpaces-8 113.4µ ± 1% 113.7µ ± 1% ~ (p=0.310 n=6) +geomean 113.1µ 113.3µ +0.15% + + │ old.txt │ new.txt │ + │ B/s │ B/s vs base │ +WrapString-8 84.92Mi ± 1% 84.82Mi ± 2% ~ (p=0.589 n=6) +WrapStringWithSpaces-8 84.43Mi ± 1% 84.27Mi ± 1% ~ (p=0.310 n=6) +geomean 84.68Mi 84.55Mi -0.15% + + │ old.txt │ new.txt │ + │ B/op │ B/op vs base │ +WrapString-8 47.35Ki ± 0% 47.35Ki ± 0% ~ (p=1.000 n=6) ¹ +WrapStringWithSpaces-8 52.76Ki ± 0% 52.76Ki ± 0% ~ (p=1.000 n=6) ¹ +geomean 49.98Ki 49.98Ki +0.00% +¹ all samples are equal + + │ old.txt │ new.txt │ + │ allocs/op │ allocs/op vs base │ +WrapString-8 33.00 ± 0% 33.00 ± 0% ~ (p=1.000 n=6) ¹ +WrapStringWithSpaces-8 51.00 ± 0% 51.00 ± 0% ~ (p=1.000 n=6) ¹ +geomean 41.02 41.02 +0.00% +¹ all samples are equal + +pkg: github.com/olekukonko/tablewriter/pkg/twwidth + │ old.txt │ new.txt │ + │ sec/op │ sec/op vs base │ +WidthFunction/SimpleASCII_EAfalse_NoCache-8 387.6n ± 1% 368.4n ± 2% -4.97% (p=0.002 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheMiss-8 219.0n ± 127% 217.5n ± 119% ~ (p=0.372 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheHit-8 14.78n ± 1% 14.54n ± 3% ~ (p=0.061 n=6) +WidthFunction/SimpleASCII_EAtrue_NoCache-8 676.4n ± 1% 366.8n ± 2% -45.77% (p=0.002 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheMiss-8 216.1n ± 375% 216.0n ± 128% ~ (p=0.937 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheHit-8 14.71n ± 0% 14.49n ± 0% -1.53% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1.027µ ± 3% 1.007µ ± 1% -2.00% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 219.5n ± 516% 221.4n ± 502% ~ (p=0.515 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 14.81n ± 1% 14.61n ± 1% -1.35% (p=0.009 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1.313µ ± 2% 1.009µ ± 2% -23.15% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 653.2n ± 150% 218.2n ± 524% ~ (p=0.331 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 14.73n ± 2% 14.50n ± 0% -1.60% (p=0.002 n=6) +WidthFunction/EastAsian_EAfalse_NoCache-8 747.3n ± 1% 336.2n ± 1% -55.02% (p=0.002 n=6) +WidthFunction/EastAsian_EAfalse_CacheMiss-8 226.3n ± 384% 227.4n ± 113% ~ (p=0.937 n=6) +WidthFunction/EastAsian_EAfalse_CacheHit-8 14.74n ± 1% 14.58n ± 1% -1.09% (p=0.011 n=6) +WidthFunction/EastAsian_EAtrue_NoCache-8 965.4n ± 2% 348.7n ± 0% -63.88% (p=0.002 n=6) +WidthFunction/EastAsian_EAtrue_CacheMiss-8 225.4n ± 511% 225.8n ± 111% ~ (p=1.000 n=6) +WidthFunction/EastAsian_EAtrue_CacheHit-8 14.72n ± 1% 14.54n ± 3% ~ (p=0.056 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1376.0n ± 2% 983.8n ± 2% -28.50% (p=0.002 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 633.6n ± 170% 222.4n ± 513% ~ (p=0.974 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 15.73n ± 1% 15.64n ± 1% ~ (p=0.227 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1589.5n ± 1% 996.9n ± 2% -37.29% (p=0.002 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 484.8n ± 309% 221.3n ± 516% ~ (p=0.240 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 15.74n ± 1% 15.73n ± 1% ~ (p=0.485 n=6) +WidthFunction/LongSimpleASCII_EAfalse_NoCache-8 4.916µ ± 3% 4.512µ ± 4% -8.22% (p=0.002 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 2.430µ ± 114% 2.182µ ± 123% ~ (p=0.699 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 23.75n ± 3% 23.24n ± 3% ~ (p=0.065 n=6) +WidthFunction/LongSimpleASCII_EAtrue_NoCache-8 9.273µ ± 1% 4.519µ ± 1% -51.27% (p=0.002 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 4.021µ ± 131% 2.127µ ± 128% ~ (p=0.240 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 23.50n ± 2% 23.48n ± 1% ~ (p=0.589 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 57.36µ ± 1% 57.33µ ± 2% ~ (p=0.818 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 22.18µ ± 135% 14.55µ ± 299% ~ (p=0.589 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 44.21n ± 1% 44.20n ± 2% ~ (p=0.818 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 60.25µ ± 2% 57.90µ ± 2% -3.90% (p=0.002 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 16.11µ ± 263% 20.02µ ± 183% ~ (p=0.699 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 44.57n ± 1% 44.18n ± 2% ~ (p=0.461 n=6) +geomean 358.5n 283.9n -20.82% + + │ old.txt │ new.txt │ + │ B/s │ B/s vs base │ +WidthFunction/SimpleASCII_EAfalse_NoCache-8 86.11Mi ± 1% 90.63Mi ± 2% +5.24% (p=0.002 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheMiss-8 152.4Mi ± 56% 153.5Mi ± 54% ~ (p=0.394 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheHit-8 2.205Gi ± 1% 2.242Gi ± 3% ~ (p=0.065 n=6) +WidthFunction/SimpleASCII_EAtrue_NoCache-8 49.35Mi ± 1% 91.00Mi ± 2% +84.40% (p=0.002 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheMiss-8 154.5Mi ± 79% 154.5Mi ± 56% ~ (p=0.937 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheHit-8 2.215Gi ± 0% 2.250Gi ± 0% +1.58% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 56.66Mi ± 2% 57.78Mi ± 1% +1.99% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 265.1Mi ± 84% 262.7Mi ± 83% ~ (p=0.485 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 3.836Gi ± 1% 3.888Gi ± 1% +1.34% (p=0.009 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 44.30Mi ± 2% 57.65Mi ± 2% +30.14% (p=0.002 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 147.3Mi ± 81% 266.7Mi ± 84% ~ (p=0.310 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 3.856Gi ± 2% 3.919Gi ± 0% +1.63% (p=0.002 n=6) +WidthFunction/EastAsian_EAfalse_NoCache-8 76.58Mi ± 1% 170.21Mi ± 1% +122.28% (p=0.002 n=6) +WidthFunction/EastAsian_EAfalse_CacheMiss-8 252.8Mi ± 79% 251.6Mi ± 53% ~ (p=0.937 n=6) +WidthFunction/EastAsian_EAfalse_CacheHit-8 3.791Gi ± 1% 3.832Gi ± 1% +1.08% (p=0.009 n=6) +WidthFunction/EastAsian_EAtrue_NoCache-8 59.27Mi ± 2% 164.10Mi ± 0% +176.87% (p=0.002 n=6) +WidthFunction/EastAsian_EAtrue_CacheMiss-8 253.9Mi ± 84% 253.4Mi ± 53% ~ (p=1.000 n=6) +WidthFunction/EastAsian_EAtrue_CacheHit-8 3.796Gi ± 1% 3.841Gi ± 3% ~ (p=0.065 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 60.29Mi ± 1% 84.33Mi ± 2% +39.88% (p=0.002 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 227.1Mi ± 79% 373.2Mi ± 84% ~ (p=1.000 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 5.154Gi ± 1% 5.181Gi ± 1% ~ (p=0.240 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 52.19Mi ± 1% 83.23Mi ± 2% +59.47% (p=0.002 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 230.9Mi ± 82% 374.9Mi ± 84% ~ (p=0.240 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 5.147Gi ± 1% 5.152Gi ± 1% ~ (p=0.485 n=6) +WidthFunction/LongSimpleASCII_EAfalse_NoCache-8 104.8Mi ± 3% 114.1Mi ± 4% +8.95% (p=0.002 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 368.0Mi ± 293% 474.3Mi ± 211% ~ (p=0.699 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 21.17Gi ± 3% 21.64Gi ± 2% ~ (p=0.065 n=6) +WidthFunction/LongSimpleASCII_EAtrue_NoCache-8 55.54Mi ± 1% 113.97Mi ± 1% +105.21% (p=0.002 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 399.8Mi ± 232% 577.5Mi ± 149% ~ (p=0.240 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 21.40Gi ± 2% 21.41Gi ± 1% ~ (p=0.589 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 34.08Mi ± 1% 34.10Mi ± 2% ~ (p=0.784 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 101.5Mi ± 1396% 643.9Mi ± 320% ~ (p=0.589 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 43.18Gi ± 1% 43.20Gi ± 2% ~ (p=0.818 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 32.45Mi ± 2% 33.76Mi ± 2% +4.06% (p=0.002 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 393.0Mi ± 296% 122.4Mi ± 1610% ~ (p=0.699 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 42.83Gi ± 1% 43.21Gi ± 2% ~ (p=0.485 n=6) +geomean 456.4Mi 560.6Mi +22.83% + + │ old.txt │ new.txt │ + │ B/op │ B/op vs base │ +WidthFunction/SimpleASCII_EAfalse_NoCache-8 112.0 ± 1% 113.0 ± 0% ~ (p=0.061 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheMiss-8 55.00 ± 200% 55.00 ± 202% ~ (p=1.000 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/SimpleASCII_EAtrue_NoCache-8 113.0 ± 1% 113.0 ± 0% ~ (p=1.000 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheMiss-8 55.00 ± 505% 55.00 ± 205% ~ (p=0.697 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 185.0 ± 0% 185.0 ± 1% ~ (p=0.455 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 87.00 ± 402% 87.00 ± 401% ~ (p=1.000 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 185.0 ± 0% 185.0 ± 1% ~ (p=1.000 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 174.00 ± 115% 87.00 ± 401% ~ (p=0.621 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAfalse_NoCache-8 145.0 ± 0% 146.0 ± 0% +0.69% (p=0.002 n=6) +WidthFunction/EastAsian_EAfalse_CacheMiss-8 87.00 ± 392% 87.00 ± 167% ~ (p=0.697 n=6) +WidthFunction/EastAsian_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAtrue_NoCache-8 145.0 ± 1% 146.0 ± 1% +0.69% (p=0.013 n=6) +WidthFunction/EastAsian_EAtrue_CacheMiss-8 87.00 ± 392% 87.00 ± 164% ~ (p=0.697 n=6) +WidthFunction/EastAsian_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 193.0 ± 1% 193.0 ± 0% ~ (p=1.000 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 232.0 ± 134% 103.0 ± 485% ~ (p=0.924 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 193.0 ± 0% 193.0 ± 1% ~ (p=1.000 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 185.0 ± 203% 103.0 ± 485% ~ (p=0.621 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAfalse_NoCache-8 1.153Ki ± 0% 1.150Ki ± 0% ~ (p=0.126 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 1.050Ki ± 72% 1.047Ki ± 74% ~ (p=0.939 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAtrue_NoCache-8 1.152Ki ± 0% 1.155Ki ± 0% +0.30% (p=0.015 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 1.036Ki ± 71% 1.039Ki ± 76% ~ (p=0.981 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 1.355Ki ± 0% 1.358Ki ± 0% ~ (p=0.065 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 2.787Ki ± 31% 2.613Ki ± 43% ~ (p=0.805 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 1.358Ki ± 0% 1.361Ki ± 0% ~ (p=0.158 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 2.625Ki ± 43% 2.741Ki ± 37% ~ (p=0.987 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +geomean ² -5.62% ² +¹ all samples are equal +² summaries must be >0 to compute geomean + + │ old.txt │ new.txt │ + │ allocs/op │ allocs/op vs base │ +WidthFunction/SimpleASCII_EAfalse_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/SimpleASCII_EAfalse_CacheMiss-8 1.000 ± 200% 1.000 ± 200% ~ (p=1.000 n=6) +WidthFunction/SimpleASCII_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/SimpleASCII_EAtrue_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/SimpleASCII_EAtrue_CacheMiss-8 1.000 ± 300% 1.000 ± 200% ~ (p=0.697 n=6) +WidthFunction/SimpleASCII_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 6.000 ± 0% 6.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 1.000 ± 600% 1.000 ± 600% ~ (p=1.000 n=6) +WidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 6.000 ± 0% 6.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 3.500 ± 100% 1.000 ± 600% ~ (p=0.610 n=6) +WidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAfalse_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAfalse_CacheMiss-8 1.000 ± 300% 1.000 ± 200% ~ (p=0.697 n=6) +WidthFunction/EastAsian_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAtrue_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsian_EAtrue_CacheMiss-8 1.000 ± 300% 1.000 ± 200% ~ (p=0.697 n=6) +WidthFunction/EastAsian_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 5.000 ± 0% 5.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 3.000 ± 133% 1.000 ± 600% ~ (p=1.000 n=6) +WidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 5.000 ± 0% 5.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 2.500 ± 180% 1.000 ± 600% ~ (p=0.610 n=6) +WidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAfalse_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3.000 ± 67% 3.000 ± 67% ~ (p=1.000 n=6) +WidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAtrue_NoCache-8 3.000 ± 0% 3.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3.000 ± 67% 3.000 ± 67% ~ (p=1.000 n=6) +WidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 9.000 ± 0% 9.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 5.000 ± 100% 3.500 ± 186% ~ (p=0.978 n=6) +WidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 9.000 ± 0% 9.000 ± 0% ~ (p=1.000 n=6) ¹ +WidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 4.000 ± 150% 4.500 ± 122% ~ (p=0.952 n=6) +WidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 0.000 ± 0% 0.000 ± 0% ~ (p=1.000 n=6) ¹ +geomean ² -9.28% ² +¹ all samples are equal +² summaries must be >0 to compute geomean diff --git a/vendor/github.com/olekukonko/tablewriter/config.go b/vendor/github.com/olekukonko/tablewriter/config.go index ddad9bd..415c957 100644 --- a/vendor/github.com/olekukonko/tablewriter/config.go +++ b/vendor/github.com/olekukonko/tablewriter/config.go @@ -135,12 +135,12 @@ func (b *ConfigBuilder) WithFooterMaxWidth(maxWidth int) *ConfigBuilder { return b } -// WithFooterMergeMode sets the merge behavior for footer cells (e.g., horizontal, hierarchical). -// Invalid merge modes are ignored. +// Deprecated: Use .Footer().CellMerging().WithMode(...) instead. This method will be removed in a future version. func (b *ConfigBuilder) WithFooterMergeMode(mergeMode int) *ConfigBuilder { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return b } + b.config.Footer.Merging.Mode = mergeMode b.config.Footer.Formatting.MergeMode = mergeMode return b } @@ -187,12 +187,12 @@ func (b *ConfigBuilder) WithHeaderMaxWidth(maxWidth int) *ConfigBuilder { return b } -// WithHeaderMergeMode sets the merge behavior for header cells (e.g., horizontal, vertical). -// Invalid merge modes are ignored. +// Deprecated: Use .Header().CellMerging().WithMode(...) instead. This method will be removed in a future version. func (b *ConfigBuilder) WithHeaderMergeMode(mergeMode int) *ConfigBuilder { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return b } + b.config.Header.Merging.Mode = mergeMode b.config.Header.Formatting.MergeMode = mergeMode return b } @@ -246,12 +246,12 @@ func (b *ConfigBuilder) WithRowMaxWidth(maxWidth int) *ConfigBuilder { return b } -// WithRowMergeMode sets the merge behavior for row cells (e.g., horizontal, hierarchical). -// Invalid merge modes are ignored. +// Deprecated: Use .Row().CellMerging().WithMode(...) instead. This method will be removed in a future version. func (b *ConfigBuilder) WithRowMergeMode(mergeMode int) *ConfigBuilder { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return b } + b.config.Row.Merging.Mode = mergeMode b.config.Row.Formatting.MergeMode = mergeMode return b } @@ -285,6 +285,14 @@ func (h *HeaderConfigBuilder) Formatting() *HeaderFormattingBuilder { } } +// Merging returns a HeaderMergingBuilder for configuring cell merging. +func (h *HeaderConfigBuilder) Merging() *HeaderMergingBuilder { + return &HeaderMergingBuilder{ + parent: h, + config: &h.config.Merging, + } +} + // Padding returns a HeaderPaddingBuilder for header padding func (h *HeaderConfigBuilder) Padding() *HeaderPaddingBuilder { return &HeaderPaddingBuilder{ @@ -341,6 +349,14 @@ func (r *RowConfigBuilder) Formatting() *RowFormattingBuilder { } } +// Merging returns a RowMergingBuilder for configuring cell merging. +func (r *RowConfigBuilder) Merging() *RowMergingBuilder { + return &RowMergingBuilder{ + parent: r, + config: &r.config.Merging, + } +} + // Padding returns a RowPaddingBuilder for row padding func (r *RowConfigBuilder) Padding() *RowPaddingBuilder { return &RowPaddingBuilder{ @@ -397,6 +413,14 @@ func (f *FooterConfigBuilder) Formatting() *FooterFormattingBuilder { } } +// Merging returns a FooterMergingBuilder for configuring cell merging. +func (f *FooterConfigBuilder) Merging() *FooterMergingBuilder { + return &FooterMergingBuilder{ + parent: f, + config: &f.config.Merging, + } +} + // Padding returns a FooterPaddingBuilder for footer padding func (f *FooterConfigBuilder) Padding() *FooterPaddingBuilder { return &FooterPaddingBuilder{ @@ -478,9 +502,10 @@ func (hf *HeaderFormattingBuilder) WithAutoWrap(autoWrap int) *HeaderFormattingB return hf } -// WithMergeMode sets merge mode +// Deprecated: Use .CellMerging().WithMode(...) instead. This method will be removed in a future version. func (hf *HeaderFormattingBuilder) WithMergeMode(mergeMode int) *HeaderFormattingBuilder { if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + hf.parent.config.Merging.Mode = mergeMode hf.config.MergeMode = mergeMode } return hf @@ -512,9 +537,10 @@ func (rf *RowFormattingBuilder) WithAutoWrap(autoWrap int) *RowFormattingBuilder return rf } -// WithMergeMode sets merge mode +// Deprecated: Use .CellMerging().WithMode(...) instead. This method will be removed in a future version. func (rf *RowFormattingBuilder) WithMergeMode(mergeMode int) *RowFormattingBuilder { if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + rf.parent.config.Merging.Mode = mergeMode rf.config.MergeMode = mergeMode } return rf @@ -546,14 +572,117 @@ func (ff *FooterFormattingBuilder) WithAutoWrap(autoWrap int) *FooterFormattingB return ff } -// WithMergeMode sets merge mode +// Deprecated: Use .CellMerging().WithMode(...) instead. This method will be removed in a future version. func (ff *FooterFormattingBuilder) WithMergeMode(mergeMode int) *FooterFormattingBuilder { if mergeMode >= tw.MergeNone && mergeMode <= tw.MergeHierarchical { + ff.parent.config.Merging.Mode = mergeMode ff.config.MergeMode = mergeMode } return ff } +// HeaderMergingBuilder configures header cell merging +type HeaderMergingBuilder struct { + parent *HeaderConfigBuilder + config *tw.CellMerging +} + +// Build returns the parent HeaderConfigBuilder. +func (hm *HeaderMergingBuilder) Build() *HeaderConfigBuilder { + return hm.parent +} + +// WithMode sets the merge mode (e.g., tw.MergeHorizontal). +func (hm *HeaderMergingBuilder) WithMode(mode int) *HeaderMergingBuilder { + hm.config.Mode = mode + // Also set the deprecated field for backward compatibility + hm.parent.config.Formatting.MergeMode = mode + return hm +} + +// ByColumnIndex sets specific columns to be merged by their index. +// If not called, merging applies to all columns. +func (hm *HeaderMergingBuilder) ByColumnIndex(indices []int) *HeaderMergingBuilder { + if len(indices) == 0 { + hm.config.ByColumnIndex = nil // nil means apply to all + } else { + mapper := tw.NewMapper[int, bool]() + for _, idx := range indices { + mapper.Set(idx, true) + } + hm.config.ByColumnIndex = mapper + } + return hm +} + +// RowMergingBuilder configures row cell merging +type RowMergingBuilder struct { + parent *RowConfigBuilder + config *tw.CellMerging +} + +// Build returns the parent RowConfigBuilder. +func (rm *RowMergingBuilder) Build() *RowConfigBuilder { + return rm.parent +} + +// WithMode sets the merge mode (e.g., tw.MergeVertical, tw.MergeHierarchical). +func (rm *RowMergingBuilder) WithMode(mode int) *RowMergingBuilder { + rm.config.Mode = mode + // Also set the deprecated field for backward compatibility + rm.parent.config.Formatting.MergeMode = mode + return rm +} + +// ByColumnIndex sets specific columns to be merged by their index. +// If not called, merging applies to all columns. +func (rm *RowMergingBuilder) ByColumnIndex(indices []int) *RowMergingBuilder { + if len(indices) == 0 { + rm.config.ByColumnIndex = nil // nil means apply to all + } else { + mapper := tw.NewMapper[int, bool]() + for _, idx := range indices { + mapper.Set(idx, true) + } + rm.config.ByColumnIndex = mapper + } + return rm +} + +// FooterMergingBuilder configures footer cell merging +type FooterMergingBuilder struct { + parent *FooterConfigBuilder + config *tw.CellMerging +} + +// Build returns the parent FooterConfigBuilder. +func (fm *FooterMergingBuilder) Build() *FooterConfigBuilder { + return fm.parent +} + +// WithMode sets the merge mode (e.g., tw.MergeHorizontal). +func (fm *FooterMergingBuilder) WithMode(mode int) *FooterMergingBuilder { + fm.config.Mode = mode + // Also set the deprecated field for backward compatibility + fm.parent.config.Formatting.MergeMode = mode + return fm +} + +// ByColumnIndex sets specific columns to be merged by their index. +// If not called, merging applies to all columns. +func (fm *FooterMergingBuilder) ByColumnIndex(indices []int) *FooterMergingBuilder { + if len(indices) == 0 { + fm.config.ByColumnIndex = nil // nil means apply to all + } else { + mapper := tw.NewMapper[int, bool]() + for _, idx := range indices { + mapper.Set(idx, true) + } + fm.config.ByColumnIndex = mapper + } + return fm +} + // HeaderPaddingBuilder configures header padding type HeaderPaddingBuilder struct { parent *HeaderConfigBuilder diff --git a/vendor/github.com/olekukonko/tablewriter/deprecated.go b/vendor/github.com/olekukonko/tablewriter/deprecated.go index aa119e4..013d03d 100644 --- a/vendor/github.com/olekukonko/tablewriter/deprecated.go +++ b/vendor/github.com/olekukonko/tablewriter/deprecated.go @@ -1,6 +1,8 @@ package tablewriter import ( + "github.com/mattn/go-runewidth" + "github.com/olekukonko/tablewriter/pkg/twwidth" "github.com/olekukonko/tablewriter/tw" ) @@ -218,3 +220,16 @@ func WithTableMax(width int) Option { } } } + +// Deprecated: use WithEastAsian instead. +// WithCondition provides a way to set a custom global runewidth.Condition +// that will be used for all subsequent display width calculations by the twwidth (twdw) package. +// +// The runewidth.Condition object allows for more fine-grained control over how rune widths +// are determined, beyond just toggling EastAsianWidth. This could include settings for +// ambiguous width characters or other future properties of runewidth.Condition. +func WithCondition(cond *runewidth.Condition) Option { + return func(target *Table) { + twwidth.SetCondition(cond) + } +} diff --git a/vendor/github.com/olekukonko/tablewriter/new.txt b/vendor/github.com/olekukonko/tablewriter/new.txt new file mode 100644 index 0000000..46791ad --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/new.txt @@ -0,0 +1,248 @@ +PASS +ok github.com/olekukonko/tablewriter 0.284s +? github.com/olekukonko/tablewriter/cmd/csv2table [no test files] +goos: darwin +goarch: arm64 +pkg: github.com/olekukonko/tablewriter/pkg/twwarp +cpu: Apple M2 +BenchmarkWrapString-8 10030 114909 ns/op 87.40 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112188 ns/op 89.52 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 113708 ns/op 88.32 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 113233 ns/op 88.69 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112575 ns/op 89.21 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112604 ns/op 89.19 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113731 ns/op 88.30 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113511 ns/op 88.48 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113575 ns/op 88.43 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113746 ns/op 88.29 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113473 ns/op 88.51 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 114487 ns/op 87.72 MB/s 54024 B/op 51 allocs/op +PASS +ok github.com/olekukonko/tablewriter/pkg/twwarp 14.612s +goos: darwin +goarch: arm64 +pkg: github.com/olekukonko/tablewriter/pkg/twwidth +cpu: Apple M2 +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 264374 4533 ns/op 119.12 MB/s 1178 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 265746 4514 ns/op 119.62 MB/s 1177 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 263538 4509 ns/op 119.75 MB/s 1178 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 266173 4510 ns/op 119.72 MB/s 1180 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 265224 4676 ns/op 115.48 MB/s 1180 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 265696 4508 ns/op 119.80 MB/s 1177 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 251047 4859 ns/op 111.13 MB/s 1867 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 1000000 3945 ns/op 136.89 MB/s 1584 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3504475 3729 ns/op 144.81 MB/s 1474 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3664098 635.4 ns/op 849.84 MB/s 670 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3818680 588.6 ns/op 917.47 MB/s 667 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3761966 348.7 ns/op 1548.66 MB/s 583 B/op 1 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 49524442 23.54 ns/op 22938.55 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51765230 23.25 ns/op 23221.81 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51881983 23.83 ns/op 22664.79 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51665586 23.20 ns/op 23272.39 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51782077 23.23 ns/op 23250.20 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51498277 23.21 ns/op 23267.21 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 263586 4520 ns/op 119.47 MB/s 1183 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 265484 4519 ns/op 119.49 MB/s 1182 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 265218 4514 ns/op 119.64 MB/s 1181 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 265957 4515 ns/op 119.60 MB/s 1184 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 265981 4518 ns/op 119.52 MB/s 1183 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 265028 4574 ns/op 118.06 MB/s 1184 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 251682 4853 ns/op 111.27 MB/s 1869 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 1000000 3893 ns/op 138.70 MB/s 1583 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3596130 3747 ns/op 144.13 MB/s 1499 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3671358 506.1 ns/op 1066.92 MB/s 628 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3687993 370.6 ns/op 1456.96 MB/s 594 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3672946 358.4 ns/op 1506.88 MB/s 583 B/op 1 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 49266897 23.64 ns/op 22844.78 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 50158659 23.54 ns/op 22938.83 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 50689321 23.45 ns/op 23025.77 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51113672 23.52 ns/op 22954.95 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51489162 23.21 ns/op 23269.51 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51705564 23.16 ns/op 23311.21 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20930 57159 ns/op 35.86 MB/s 1389 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20882 57502 ns/op 35.65 MB/s 1395 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 21103 57730 ns/op 35.51 MB/s 1391 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20889 56615 ns/op 36.21 MB/s 1393 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20808 58303 ns/op 35.16 MB/s 1391 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 21104 56727 ns/op 36.14 MB/s 1387 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 38569 27485 ns/op 74.59 MB/s 3041 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1000000 58061 ns/op 35.31 MB/s 3835 B/op 10 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 2124566 31025 ns/op 66.08 MB/s 3140 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1000000 1607 ns/op 1275.74 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1615826 1224 ns/op 1674.27 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1478348 722.9 ns/op 2835.84 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 23989044 44.26 ns/op 46313.25 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27268802 44.13 ns/op 46454.64 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27292006 44.51 ns/op 46054.40 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 24128786 44.99 ns/op 45569.06 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 26858004 44.09 ns/op 46497.43 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27259458 44.05 ns/op 46538.64 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20671 57887 ns/op 35.41 MB/s 1395 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20966 56795 ns/op 36.09 MB/s 1396 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20708 57092 ns/op 35.91 MB/s 1388 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20882 57917 ns/op 35.40 MB/s 1389 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 21244 58013 ns/op 35.34 MB/s 1393 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20854 58122 ns/op 35.27 MB/s 1396 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 38907 30289 ns/op 67.68 MB/s 3066 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1000000 56603 ns/op 36.22 MB/s 3835 B/op 10 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1949059 29030 ns/op 70.62 MB/s 3084 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1479127 933.7 ns/op 2195.47 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 2335996 11012 ns/op 186.17 MB/s 2548 B/op 3 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 983864 1169 ns/op 1753.75 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27291516 44.18 ns/op 46398.32 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27220657 44.18 ns/op 46402.04 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27059124 44.91 ns/op 45645.46 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 26679783 44.04 ns/op 46551.62 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27244114 44.14 ns/op 46448.19 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27221737 44.61 ns/op 45948.75 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3247359 366.1 ns/op 95.62 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3292773 370.6 ns/op 94.44 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3275070 365.3 ns/op 95.82 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3291489 365.6 ns/op 95.73 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3282121 374.9 ns/op 93.37 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3198205 375.6 ns/op 93.18 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 3092488 419.4 ns/op 83.45 MB/s 152 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6276060 476.4 ns/op 73.46 MB/s 166 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6135336 218.8 ns/op 159.98 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6175833 216.1 ns/op 161.95 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6156606 215.2 ns/op 162.63 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6160923 216.2 ns/op 161.88 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 78655855 15.02 ns/op 2330.76 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 70905223 14.59 ns/op 2398.68 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 82255629 14.49 ns/op 2415.75 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 82383864 14.48 ns/op 2417.21 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 82325931 14.49 ns/op 2415.73 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 82426311 14.66 ns/op 2386.73 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3265182 365.8 ns/op 95.68 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3275419 366.3 ns/op 95.56 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3057087 375.3 ns/op 93.26 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3239217 372.6 ns/op 93.94 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3246429 367.3 ns/op 95.29 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 3252763 365.3 ns/op 95.80 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 2986195 396.4 ns/op 88.30 MB/s 142 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6487422 493.6 ns/op 70.90 MB/s 168 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6261225 216.1 ns/op 161.99 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6154988 210.7 ns/op 166.13 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6308702 213.8 ns/op 163.69 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6120438 216.0 ns/op 162.05 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82184980 14.47 ns/op 2419.17 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 78985473 14.51 ns/op 2412.95 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82368319 14.47 ns/op 2419.30 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82366668 14.47 ns/op 2418.96 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82104614 14.53 ns/op 2409.59 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82399426 14.53 ns/op 2409.13 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1020 ns/op 59.80 MB/s 186 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1010 ns/op 60.40 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1007 ns/op 60.55 MB/s 186 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1006 ns/op 60.63 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1006 ns/op 60.65 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1006 ns/op 60.63 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 1000000 1334 ns/op 45.74 MB/s 436 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6892693 1204 ns/op 50.65 MB/s 321 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6433399 221.7 ns/op 275.14 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6323521 221.2 ns/op 275.73 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6000822 218.5 ns/op 279.15 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6329578 220.3 ns/op 276.90 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 80806719 14.65 ns/op 4163.13 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 82397774 14.63 ns/op 4169.11 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 82794307 14.76 ns/op 4134.15 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 82610730 14.59 ns/op 4180.13 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 82639170 14.58 ns/op 4183.56 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 82560049 14.45 ns/op 4222.53 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1006 ns/op 60.61 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1012 ns/op 60.29 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1030 ns/op 59.25 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1005 ns/op 60.68 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1006 ns/op 60.64 MB/s 186 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 1000000 1012 ns/op 60.26 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 1000000 1361 ns/op 44.84 MB/s 436 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6967185 1216 ns/op 50.17 MB/s 323 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6413974 219.1 ns/op 278.46 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6381684 216.9 ns/op 281.27 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6383749 216.2 ns/op 282.14 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6360810 217.3 ns/op 280.75 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 81573231 14.53 ns/op 4197.28 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82780268 14.47 ns/op 4215.84 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82845276 14.48 ns/op 4212.74 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82545850 14.51 ns/op 4203.96 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82419704 14.49 ns/op 4209.69 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82121707 14.50 ns/op 4206.82 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3552715 336.1 ns/op 178.50 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3551234 335.0 ns/op 179.09 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3588946 338.9 ns/op 177.05 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3577424 338.5 ns/op 177.25 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3554505 335.4 ns/op 178.89 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 3575703 336.2 ns/op 178.46 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 2990224 412.6 ns/op 145.42 MB/s 207 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 6066997 484.0 ns/op 123.95 MB/s 232 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5743347 224.3 ns/op 267.49 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5870154 220.6 ns/op 271.92 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5880489 228.0 ns/op 263.14 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5660132 226.8 ns/op 264.52 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 81708613 14.54 ns/op 4126.40 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 79903231 14.65 ns/op 4094.56 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 80580853 14.62 ns/op 4103.14 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 82036092 14.73 ns/op 4073.52 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 83622964 14.49 ns/op 4139.65 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 82724623 14.53 ns/op 4129.78 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3463408 349.4 ns/op 171.71 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3245782 350.0 ns/op 171.41 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3461160 348.3 ns/op 172.28 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3453544 349.1 ns/op 171.87 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3443858 347.0 ns/op 172.92 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 3469286 347.4 ns/op 172.72 MB/s 146 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 3050086 428.5 ns/op 140.04 MB/s 213 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5927800 476.0 ns/op 126.05 MB/s 230 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5852149 223.0 ns/op 269.05 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5721747 224.9 ns/op 266.80 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5751147 225.7 ns/op 265.84 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5893626 225.9 ns/op 265.55 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81984477 14.52 ns/op 4132.81 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 79537578 14.59 ns/op 4112.59 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 82339353 14.56 ns/op 4119.49 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 82286889 14.92 ns/op 4020.68 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 82166224 14.53 ns/op 4129.14 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 83084276 14.52 ns/op 4131.45 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1221180 982.5 ns/op 88.55 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1210902 983.5 ns/op 88.46 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1223528 989.3 ns/op 87.94 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1212517 984.1 ns/op 88.40 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1224182 983.5 ns/op 88.46 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 1000000 1007 ns/op 86.36 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 999058 1364 ns/op 63.76 MB/s 603 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6682279 1218 ns/op 71.40 MB/s 465 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6339568 220.6 ns/op 394.46 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6226921 222.3 ns/op 391.34 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6264051 221.1 ns/op 393.47 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6234439 222.4 ns/op 391.23 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 75337251 15.64 ns/op 5562.01 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76826634 15.76 ns/op 5521.54 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76836674 15.79 ns/op 5508.81 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76840162 15.64 ns/op 5564.05 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76694060 15.60 ns/op 5577.81 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76737175 15.62 ns/op 5571.56 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1202406 1012 ns/op 85.93 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1000000 1000 ns/op 86.99 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1208559 993.7 ns/op 87.55 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1209415 990.9 ns/op 87.80 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1206118 1020 ns/op 85.33 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 1211994 990.6 ns/op 87.82 MB/s 194 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 1000000 1363 ns/op 63.84 MB/s 603 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6504960 1214 ns/op 71.65 MB/s 465 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6349030 220.2 ns/op 395.18 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6183368 220.3 ns/op 394.99 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6240484 220.6 ns/op 394.32 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6280713 222.0 ns/op 391.95 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 69630140 15.77 ns/op 5517.31 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76043014 15.65 ns/op 5559.61 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76239080 15.63 ns/op 5567.94 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 75864739 15.88 ns/op 5479.13 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 71286422 15.74 ns/op 5527.29 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 75704404 15.71 ns/op 5536.58 MB/s 0 B/op 0 allocs/op +PASS +ok github.com/olekukonko/tablewriter/pkg/twwidth 659.150s +? github.com/olekukonko/tablewriter/renderer [no test files] +PASS +ok github.com/olekukonko/tablewriter/tests 3.025s +PASS +ok github.com/olekukonko/tablewriter/tw 0.283s diff --git a/vendor/github.com/olekukonko/tablewriter/old.txt b/vendor/github.com/olekukonko/tablewriter/old.txt new file mode 100644 index 0000000..f9916ea --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/old.txt @@ -0,0 +1,248 @@ +PASS +ok github.com/olekukonko/tablewriter 0.819s +? github.com/olekukonko/tablewriter/cmd/csv2table [no test files] +goos: darwin +goarch: arm64 +pkg: github.com/olekukonko/tablewriter/pkg/twwarp +cpu: Apple M2 +BenchmarkWrapString-8 10630 111320 ns/op 90.22 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112981 ns/op 88.89 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 113419 ns/op 88.55 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112794 ns/op 89.04 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112400 ns/op 89.35 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapString-8 10000 112767 ns/op 89.06 MB/s 48488 B/op 33 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 115098 ns/op 87.26 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113343 ns/op 88.61 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113702 ns/op 88.33 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113547 ns/op 88.45 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113016 ns/op 88.86 MB/s 54024 B/op 51 allocs/op +BenchmarkWrapStringWithSpaces-8 10000 113206 ns/op 88.71 MB/s 54024 B/op 51 allocs/op +PASS +ok github.com/olekukonko/tablewriter/pkg/twwarp 15.179s +goos: darwin +goarch: arm64 +pkg: github.com/olekukonko/tablewriter/pkg/twwidth +cpu: Apple M2 +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 2953855 387.1 ns/op 90.40 MB/s 112 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3095179 387.8 ns/op 90.24 MB/s 112 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3096141 391.0 ns/op 89.51 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3090711 387.2 ns/op 90.40 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3066110 387.4 ns/op 90.35 MB/s 112 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_NoCache-8 3098689 389.2 ns/op 89.92 MB/s 112 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 3125685 440.9 ns/op 79.39 MB/s 159 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6477175 496.2 ns/op 70.53 MB/s 165 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6019939 217.7 ns/op 160.79 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6231590 219.2 ns/op 159.67 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6245622 216.2 ns/op 161.90 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheMiss-8 6109658 218.8 ns/op 159.95 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 80977806 14.73 ns/op 2375.87 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 80972566 14.76 ns/op 2371.06 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 81432532 14.90 ns/op 2348.78 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 80644483 14.85 ns/op 2357.10 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 81361905 14.79 ns/op 2365.80 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAfalse_CacheHit-8 81612987 14.78 ns/op 2368.60 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1777732 682.2 ns/op 51.30 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1778122 672.9 ns/op 52.01 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1779956 674.0 ns/op 51.93 MB/s 112 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1773282 678.7 ns/op 51.57 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1783092 680.2 ns/op 51.46 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_NoCache-8 1780448 674.0 ns/op 51.93 MB/s 113 B/op 3 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 1000000 1027 ns/op 34.08 MB/s 333 B/op 4 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6891168 958.3 ns/op 36.52 MB/s 227 B/op 4 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6165972 211.7 ns/op 165.30 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6370098 217.4 ns/op 161.02 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6193920 214.8 ns/op 162.92 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheMiss-8 6190384 209.4 ns/op 167.16 MB/s 55 B/op 1 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 79747688 14.75 ns/op 2372.71 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 79607492 14.75 ns/op 2372.90 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 81634501 14.73 ns/op 2376.30 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 81644916 14.70 ns/op 2381.26 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 82505884 14.70 ns/op 2380.77 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/SimpleASCII_EAtrue_CacheHit-8 81840265 14.70 ns/op 2380.34 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1053 ns/op 57.95 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1028 ns/op 59.34 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1029 ns/op 59.27 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1025 ns/op 59.49 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1026 ns/op 59.48 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_NoCache-8 1000000 1025 ns/op 59.54 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 1000000 1352 ns/op 45.13 MB/s 437 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6619118 1219 ns/op 50.06 MB/s 320 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6486976 221.2 ns/op 275.81 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6508150 217.8 ns/op 280.07 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6487533 217.4 ns/op 280.56 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheMiss-8 6243558 216.4 ns/op 281.93 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 80787679 14.90 ns/op 4093.19 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 81640521 14.89 ns/op 4097.92 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 81596338 14.71 ns/op 4145.47 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 81950889 14.84 ns/op 4111.86 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 79321578 14.78 ns/op 4126.88 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAfalse_CacheHit-8 81880058 14.75 ns/op 4134.44 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 906406 1313 ns/op 46.44 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 917503 1313 ns/op 46.46 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 915308 1312 ns/op 46.49 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 918404 1312 ns/op 46.51 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 892551 1338 ns/op 45.58 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_NoCache-8 915020 1333 ns/op 45.76 MB/s 185 B/op 6 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 791368 1633 ns/op 37.36 MB/s 374 B/op 7 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 2314653 1064 ns/op 57.34 MB/s 265 B/op 5 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6531552 1198 ns/op 50.94 MB/s 258 B/op 5 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6629763 242.5 ns/op 251.57 MB/s 90 B/op 2 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6388215 219.1 ns/op 278.36 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheMiss-8 6472197 218.6 ns/op 279.09 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 80704821 14.76 ns/op 4132.33 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82628028 14.70 ns/op 4149.56 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 81870517 14.70 ns/op 4148.97 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 81944124 14.99 ns/op 4068.84 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 81918950 14.70 ns/op 4150.75 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/ASCIIWithANSI_EAtrue_CacheHit-8 82547270 14.91 ns/op 4092.20 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1604370 749.9 ns/op 80.02 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1610148 749.7 ns/op 80.03 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1585026 744.8 ns/op 80.56 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1615032 749.9 ns/op 80.01 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1614980 743.3 ns/op 80.72 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_NoCache-8 1609586 741.8 ns/op 80.88 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 1000000 1095 ns/op 54.77 MB/s 428 B/op 4 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 6214893 995.6 ns/op 60.26 MB/s 316 B/op 4 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5702408 224.5 ns/op 267.21 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5712139 220.2 ns/op 272.50 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5783916 228.2 ns/op 262.91 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheMiss-8 5713358 224.0 ns/op 267.91 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 78757815 14.92 ns/op 4020.51 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 81419875 14.79 ns/op 4057.15 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 81656493 14.75 ns/op 4068.12 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 81522430 14.73 ns/op 4073.37 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 81887037 14.70 ns/op 4080.93 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAfalse_CacheHit-8 82019505 14.72 ns/op 4074.99 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1241600 965.5 ns/op 62.14 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1243646 964.8 ns/op 62.19 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1243516 968.1 ns/op 61.98 MB/s 144 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1241917 965.3 ns/op 62.16 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1242903 985.0 ns/op 60.92 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_NoCache-8 1223456 964.3 ns/op 62.22 MB/s 145 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 1000000 1378 ns/op 43.55 MB/s 428 B/op 4 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 6265657 1229 ns/op 48.84 MB/s 316 B/op 4 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5960497 224.3 ns/op 267.52 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5961004 222.6 ns/op 269.52 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5772004 226.5 ns/op 264.87 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheMiss-8 5766748 223.5 ns/op 268.51 MB/s 87 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 78664455 14.76 ns/op 4063.92 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81305858 14.71 ns/op 4079.19 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81626406 14.71 ns/op 4078.32 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81168830 14.71 ns/op 4077.52 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81860040 14.72 ns/op 4075.37 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsian_EAtrue_CacheHit-8 81093633 14.88 ns/op 4031.15 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 837949 1397 ns/op 62.29 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 869082 1380 ns/op 63.04 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 864015 1377 ns/op 63.18 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 873742 1374 ns/op 63.33 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 875703 1375 ns/op 63.27 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_NoCache-8 866865 1375 ns/op 63.26 MB/s 194 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 772100 1709 ns/op 50.91 MB/s 543 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 2127564 1046 ns/op 83.14 MB/s 361 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6476034 1274 ns/op 68.30 MB/s 381 B/op 6 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6401709 221.3 ns/op 393.18 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6368766 220.2 ns/op 395.14 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheMiss-8 6404850 220.6 ns/op 394.34 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 74606566 15.83 ns/op 5494.39 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76326774 15.72 ns/op 5536.01 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76140116 15.74 ns/op 5525.94 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76340330 15.69 ns/op 5544.89 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76240900 15.69 ns/op 5544.81 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAfalse_CacheHit-8 76301294 15.73 ns/op 5531.49 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 753624 1592 ns/op 54.64 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 757292 1599 ns/op 54.42 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 758196 1588 ns/op 54.79 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 753902 1586 ns/op 54.85 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 758770 1589 ns/op 54.74 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_NoCache-8 757748 1590 ns/op 54.71 MB/s 193 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 653979 1985 ns/op 43.82 MB/s 561 B/op 7 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 2344717 731.5 ns/op 118.93 MB/s 263 B/op 3 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6440574 1420 ns/op 61.26 MB/s 369 B/op 5 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6506366 238.2 ns/op 365.22 MB/s 107 B/op 2 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6504939 220.8 ns/op 394.05 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheMiss-8 6399746 221.0 ns/op 393.66 MB/s 103 B/op 1 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 75646941 15.95 ns/op 5453.57 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 75406885 15.73 ns/op 5532.42 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76186243 15.69 ns/op 5545.76 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76350855 15.76 ns/op 5521.29 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76240896 15.70 ns/op 5542.36 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/EastAsianWithANSI_EAtrue_CacheHit-8 76404126 15.90 ns/op 5471.17 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 241440 4945 ns/op 109.19 MB/s 1181 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 245013 5050 ns/op 106.94 MB/s 1180 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 245098 4887 ns/op 110.49 MB/s 1177 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 244785 4971 ns/op 108.62 MB/s 1179 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 245007 4880 ns/op 110.66 MB/s 1182 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_NoCache-8 245986 4878 ns/op 110.71 MB/s 1181 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 232534 5203 ns/op 103.78 MB/s 1845 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 1000000 4309 ns/op 125.31 MB/s 1613 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3491629 4013 ns/op 134.57 MB/s 1471 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3670467 847.5 ns/op 637.15 MB/s 680 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3669694 385.0 ns/op 1402.66 MB/s 583 B/op 1 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheMiss-8 3242532 356.5 ns/op 1514.63 MB/s 583 B/op 1 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 50391319 23.77 ns/op 22714.54 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51225590 23.32 ns/op 23159.25 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 51732408 23.74 ns/op 22751.21 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 46074986 24.16 ns/op 22352.67 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 43649127 24.43 ns/op 22104.61 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAfalse_CacheHit-8 49954903 23.53 ns/op 22952.45 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 127574 9378 ns/op 57.58 MB/s 1180 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 128386 9386 ns/op 57.53 MB/s 1183 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 128604 9280 ns/op 58.19 MB/s 1178 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 129218 9264 ns/op 58.29 MB/s 1179 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 129030 9261 ns/op 58.31 MB/s 1179 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_NoCache-8 129080 9266 ns/op 58.28 MB/s 1180 B/op 3 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 123823 9282 ns/op 58.18 MB/s 1817 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 1000000 8943 ns/op 60.38 MB/s 1754 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3532728 7337 ns/op 73.60 MB/s 1481 B/op 4 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3610767 705.9 ns/op 764.94 MB/s 626 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3502867 387.5 ns/op 1393.73 MB/s 583 B/op 1 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheMiss-8 3706471 680.7 ns/op 793.25 MB/s 640 B/op 2 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51185895 24.01 ns/op 22492.97 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51442992 23.44 ns/op 23041.30 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 47312392 23.56 ns/op 22917.72 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51727110 23.33 ns/op 23144.01 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51212746 23.62 ns/op 22862.18 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongSimpleASCII_EAtrue_CacheHit-8 51598200 23.23 ns/op 23247.62 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 21105 57258 ns/op 35.80 MB/s 1389 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20656 57558 ns/op 35.62 MB/s 1386 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 21045 57257 ns/op 35.80 MB/s 1386 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20884 57463 ns/op 35.68 MB/s 1391 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 20984 56898 ns/op 36.03 MB/s 1388 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_NoCache-8 21164 57796 ns/op 35.47 MB/s 1388 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 103934 31906 ns/op 64.25 MB/s 3143 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1000000 52097 ns/op 39.35 MB/s 3737 B/op 10 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1298925 14140 ns/op 144.98 MB/s 2637 B/op 4 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1000000 1288 ns/op 1592.17 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 2546826 30224 ns/op 67.83 MB/s 3071 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheMiss-8 1000000 8376 ns/op 244.74 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 25786026 44.71 ns/op 45849.62 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27173578 44.15 ns/op 46427.72 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27221428 44.54 ns/op 46030.74 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27213686 44.07 ns/op 46519.79 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27233990 44.27 ns/op 46310.26 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAfalse_CacheHit-8 27164018 44.12 ns/op 46460.92 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 19785 60051 ns/op 34.14 MB/s 1386 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 20198 60161 ns/op 34.08 MB/s 1391 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 19585 60345 ns/op 33.97 MB/s 1390 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 19956 61714 ns/op 33.22 MB/s 1391 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 19554 61682 ns/op 33.24 MB/s 1388 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_NoCache-8 19830 60050 ns/op 34.14 MB/s 1393 B/op 9 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 38818 29507 ns/op 69.48 MB/s 3059 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1000000 58539 ns/op 35.02 MB/s 3835 B/op 10 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 2186653 33757 ns/op 60.73 MB/s 3157 B/op 6 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1000000 1283 ns/op 1597.72 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 1653430 1256 ns/op 1632.67 MB/s 2311 B/op 1 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheMiss-8 2195628 2716 ns/op 754.79 MB/s 2317 B/op 2 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 26531894 44.76 ns/op 45801.05 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 26634384 44.68 ns/op 45878.57 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27184633 44.97 ns/op 45583.96 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27011893 44.46 ns/op 46104.62 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27183812 44.09 ns/op 46498.94 MB/s 0 B/op 0 allocs/op +BenchmarkWidthFunction/LongASCIIWithANSI_EAtrue_CacheHit-8 27269318 44.17 ns/op 46406.38 MB/s 0 B/op 0 allocs/op +PASS +ok github.com/olekukonko/tablewriter/pkg/twwidth 724.296s +? github.com/olekukonko/tablewriter/renderer [no test files] +PASS +ok github.com/olekukonko/tablewriter/tests 2.959s +PASS +ok github.com/olekukonko/tablewriter/tw 0.270s diff --git a/vendor/github.com/olekukonko/tablewriter/option.go b/vendor/github.com/olekukonko/tablewriter/option.go index 2c1f3a2..0ec9844 100644 --- a/vendor/github.com/olekukonko/tablewriter/option.go +++ b/vendor/github.com/olekukonko/tablewriter/option.go @@ -3,8 +3,8 @@ package tablewriter import ( "reflect" - "github.com/mattn/go-runewidth" "github.com/olekukonko/ll" + "github.com/olekukonko/tablewriter/pkg/twcache" "github.com/olekukonko/tablewriter/pkg/twwidth" "github.com/olekukonko/tablewriter/tw" ) @@ -122,13 +122,14 @@ func WithFooterAlignmentConfig(alignment tw.CellAlignment) Option { } } -// WithFooterMergeMode sets the merge mode for footer cells. -// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +// Deprecated: Use a ConfigBuilder with .Footer().CellMerging().WithMode(...) instead. +// This option will be removed in a future version. func WithFooterMergeMode(mergeMode int) Option { return func(target *Table) { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return } + target.config.Footer.Merging.Mode = mergeMode target.config.Footer.Formatting.MergeMode = mergeMode if target.logger != nil { target.logger.Debugf("Option: WithFooterMergeMode applied to Table: %v", mergeMode) @@ -232,13 +233,14 @@ func WithHeaderAutoWrap(wrap int) Option { } } -// WithHeaderMergeMode sets the merge mode for header cells. -// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +// Deprecated: Use a ConfigBuilder with .Header().CellMerging().WithMode(...) instead. +// This option will be removed in a future version. func WithHeaderMergeMode(mergeMode int) Option { return func(target *Table) { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return } + target.config.Header.Merging.Mode = mergeMode target.config.Header.Formatting.MergeMode = mergeMode if target.logger != nil { target.logger.Debugf("Option: WithHeaderMergeMode applied to Table: %v", mergeMode) @@ -321,13 +323,14 @@ func WithRowAutoWrap(wrap int) Option { } } -// WithRowMergeMode sets the merge mode for row cells. -// Invalid merge modes are ignored, and the change is logged if debugging is enabled. +// Deprecated: Use a ConfigBuilder with .Row().CellMerging().WithMode(...) instead. +// This option will be removed in a future version. func WithRowMergeMode(mergeMode int) Option { return func(target *Table) { if mergeMode < tw.MergeNone || mergeMode > tw.MergeHierarchical { return } + target.config.Row.Merging.Mode = mergeMode target.config.Row.Formatting.MergeMode = mergeMode if target.logger != nil { target.logger.Debugf("Option: WithRowMergeMode applied to Table: %v", mergeMode) @@ -468,22 +471,48 @@ func WithStreaming(c tw.StreamConfig) Option { func WithStringer(stringer interface{}) Option { return func(t *Table) { t.stringer = stringer - t.stringerCacheMu.Lock() - t.stringerCache = make(map[reflect.Type]reflect.Value) - t.stringerCacheMu.Unlock() + t.stringerCache = twcache.NewLRU[reflect.Type, reflect.Value](tw.DefaultCacheStringCapacity) if t.logger != nil { t.logger.Debug("Stringer updated, cache cleared") } } } -// WithStringerCache enables caching for the stringer function. -// Logs the change if debugging is enabled. +// WithStringerCache enables the default LRU caching for the stringer function. +// It initializes the cache with a default capacity if one does not already exist. func WithStringerCache() Option { return func(t *Table) { - t.stringerCacheEnabled = true + // Initialize default cache if strictly necessary (nil), + // or if you want to ensure the default implementation is used. + if t.stringerCache == nil { + // NewLRU returns (Instance, error). We ignore the error here assuming capacity > 0. + cache := twcache.NewLRU[reflect.Type, reflect.Value](tw.DefaultCacheStringCapacity) + t.stringerCache = cache + } + if t.logger != nil { - t.logger.Debug("Option: WithStringerCache enabled") + t.logger.Debug("Option: WithStringerCache enabled (Default LRU)") + } + } +} + +// WithStringerCacheCustom enables caching for the stringer function using a specific implementation. +// Passing nil disables caching entirely. +func WithStringerCacheCustom(cache twcache.Cache[reflect.Type, reflect.Value]) Option { + return func(t *Table) { + if cache == nil { + t.stringerCache = nil + if t.logger != nil { + t.logger.Debug("Option: WithStringerCacheCustom called with nil (Caching Disabled)") + } + return + } + + // Set the custom cache and enable the flag + t.stringerCache = cache + + if t.logger != nil { + t.logger.Debug("Option: WithStringerCacheCustom enabled") } } } @@ -626,27 +655,20 @@ func WithRendition(rendition tw.Rendition) Option { } // WithEastAsian configures the global East Asian width calculation setting. -// - enable=true: Enables East Asian width calculations. CJK and ambiguous characters +// - state=tw.On: Enables East Asian width calculations. CJK and ambiguous characters // are typically measured as double width. -// - enable=false: Disables East Asian width calculations. Characters are generally +// - state=tw.Off: Disables East Asian width calculations. Characters are generally // measured as single width, subject to Unicode standards. // // This setting affects all subsequent display width calculations using the twdw package. -func WithEastAsian(enable bool) Option { +func WithEastAsian(state tw.State) Option { return func(target *Table) { - twwidth.SetEastAsian(enable) - } -} - -// WithCondition provides a way to set a custom global runewidth.Condition -// that will be used for all subsequent display width calculations by the twwidth (twdw) package. -// -// The runewidth.Condition object allows for more fine-grained control over how rune widths -// are determined, beyond just toggling EastAsianWidth. This could include settings for -// ambiguous width characters or other future properties of runewidth.Condition. -func WithCondition(condition *runewidth.Condition) Option { - return func(target *Table) { - twwidth.SetCondition(condition) + if state.Enabled() { + twwidth.SetEastAsian(true) + } + if state.Disabled() { + twwidth.SetEastAsian(false) + } } } @@ -706,6 +728,9 @@ func defaultConfig() Config { AutoFormat: tw.On, MergeMode: tw.MergeNone, }, + Merging: tw.CellMerging{ + Mode: tw.MergeNone, + }, Padding: tw.CellPadding{ Global: tw.PaddingDefault, }, @@ -720,6 +745,9 @@ func defaultConfig() Config { AutoFormat: tw.Off, MergeMode: tw.MergeNone, }, + Merging: tw.CellMerging{ + Mode: tw.MergeNone, + }, Padding: tw.CellPadding{ Global: tw.PaddingDefault, }, @@ -734,6 +762,9 @@ func defaultConfig() Config { AutoFormat: tw.Off, MergeMode: tw.MergeNone, }, + Merging: tw.CellMerging{ + Mode: tw.MergeNone, + }, Padding: tw.CellPadding{ Global: tw.PaddingDefault, }, @@ -772,10 +803,20 @@ func mergeCellConfig(dst, src tw.CellConfig) tw.CellConfig { if src.ColMaxWidths.Global != 0 { dst.ColMaxWidths.Global = src.ColMaxWidths.Global } - if src.Formatting.MergeMode != 0 { + + // Handle merging of the new CellMerging struct and the deprecated MergeMode + if src.Merging.Mode != 0 { + dst.Merging.Mode = src.Merging.Mode + dst.Formatting.MergeMode = src.Merging.Mode + } else if src.Formatting.MergeMode != 0 { + dst.Merging.Mode = src.Formatting.MergeMode dst.Formatting.MergeMode = src.Formatting.MergeMode } + if src.Merging.ByColumnIndex != nil { + dst.Merging.ByColumnIndex = src.Merging.ByColumnIndex.Clone() + } + dst.Formatting.AutoFormat = src.Formatting.AutoFormat if src.Padding.Global.Paddable() { diff --git a/vendor/github.com/olekukonko/tablewriter/pkg/twcache/cache.go b/vendor/github.com/olekukonko/tablewriter/pkg/twcache/cache.go new file mode 100644 index 0000000..09bd02b --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/pkg/twcache/cache.go @@ -0,0 +1,12 @@ +package twcache + +// Cache defines a generic interface for a key-value storage with type constraints on keys and values. +// The keys must be of a type that supports comparison. +// Add inserts a new key-value pair, potentially evicting an item if necessary. +// Get retrieves a value associated with the given key, returning a boolean to indicate if the key was found. +// Purge clears all items from the cache. +type Cache[K comparable, V any] interface { + Add(key K, value V) (evicted bool) + Get(key K) (value V, ok bool) + Purge() +} diff --git a/vendor/github.com/olekukonko/tablewriter/pkg/twcache/lru.go b/vendor/github.com/olekukonko/tablewriter/pkg/twcache/lru.go new file mode 100644 index 0000000..7b11cd6 --- /dev/null +++ b/vendor/github.com/olekukonko/tablewriter/pkg/twcache/lru.go @@ -0,0 +1,289 @@ +package twcache + +import ( + "sync" + "sync/atomic" +) + +// EvictCallback is a function called when an entry is evicted. +// This includes evictions during Purge or Resize operations. +type EvictCallback[K comparable, V any] func(key K, value V) + +// LRU is a thread-safe, generic LRU cache with a fixed size. +// It has zero dependencies, high performance, and full features. +type LRU[K comparable, V any] struct { + size int + items map[K]*entry[K, V] + head *entry[K, V] // Most Recently Used + tail *entry[K, V] // Least Recently Used + onEvict EvictCallback[K, V] + + mu sync.Mutex + hits atomic.Int64 + misses atomic.Int64 +} + +// entry represents a single item in the LRU linked list. +// It holds the key, value, and pointers to prev/next entries. +type entry[K comparable, V any] struct { + key K + value V + prev *entry[K, V] + next *entry[K, V] +} + +// NewLRU creates a new LRU cache with the given size. +// Returns nil if size <= 0, acting as a disabled cache. +// Caps size at 100,000 for reasonableness. +func NewLRU[K comparable, V any](size int) *LRU[K, V] { + return NewLRUEvict[K, V](size, nil) +} + +// NewLRUEvict creates a new LRU cache with an eviction callback. +// The callback is optional and called on evictions. +// Returns nil if size <= 0. +func NewLRUEvict[K comparable, V any](size int, onEvict EvictCallback[K, V]) *LRU[K, V] { + if size <= 0 { + return nil // nil = disabled cache (fast path in hot code) + } + if size > 100_000 { + size = 100_000 // reasonable upper bound + } + return &LRU[K, V]{ + size: size, + items: make(map[K]*entry[K, V], size), + onEvict: onEvict, + } +} + +// GetOrCompute retrieves a value or computes it if missing. +// Ensures no double computation under concurrency. +// Ideal for expensive computations like twwidth. +func (c *LRU[K, V]) GetOrCompute(key K, compute func() V) V { + if c == nil || c.size <= 0 { + return compute() + } + + c.mu.Lock() + if e, ok := c.items[key]; ok { + c.moveToFront(e) + c.hits.Add(1) + c.mu.Unlock() + return e.value + } + + c.misses.Add(1) + value := compute() // expensive work only on real miss + + // Double-check: someone might have added it while computing + if e, ok := c.items[key]; ok { + e.value = value + c.moveToFront(e) + c.mu.Unlock() + return value + } + + // Evict if needed + if len(c.items) >= c.size { + c.removeOldest() + } + + e := &entry[K, V]{key: key, value: value} + c.addToFront(e) + c.items[key] = e + c.mu.Unlock() + return value +} + +// Get retrieves a value by key if it exists. +// Returns the value and true if found, else zero and false. +// Updates the entry to most recently used. +func (c *LRU[K, V]) Get(key K) (V, bool) { + if c == nil || c.size <= 0 { + var zero V + return zero, false + } + c.mu.Lock() + defer c.mu.Unlock() + + e, ok := c.items[key] + if !ok { + c.misses.Add(1) + var zero V + return zero, false + } + c.hits.Add(1) + c.moveToFront(e) + return e.value, true +} + +// Add inserts or updates a key-value pair. +// Evicts the oldest if cache is full. +// Returns true if an eviction occurred. +func (c *LRU[K, V]) Add(key K, value V) (evicted bool) { + if c == nil || c.size <= 0 { + return false + } + c.mu.Lock() + defer c.mu.Unlock() + + if e, ok := c.items[key]; ok { + e.value = value + c.moveToFront(e) + return false + } + + if len(c.items) >= c.size { + c.removeOldest() + evicted = true + } + + e := &entry[K, V]{key: key, value: value} + c.addToFront(e) + c.items[key] = e + return evicted +} + +// Remove deletes a key from the cache. +// Returns true if the key was found and removed. +func (c *LRU[K, V]) Remove(key K) bool { + if c == nil || c.size <= 0 { + return false + } + c.mu.Lock() + defer c.mu.Unlock() + + e, ok := c.items[key] + if !ok { + return false + } + c.removeNode(e) + delete(c.items, key) + return true +} + +// Purge clears all entries from the cache. +// Calls onEvict for each entry if set. +// Resets hit/miss counters. +func (c *LRU[K, V]) Purge() { + if c == nil || c.size <= 0 { + return + } + c.mu.Lock() + if c.onEvict != nil { + for key, e := range c.items { + c.onEvict(key, e.value) + } + } + c.items = make(map[K]*entry[K, V], c.size) + c.head = nil + c.tail = nil + c.hits.Store(0) + c.misses.Store(0) + c.mu.Unlock() +} + +// Len returns the current number of items in the cache. +func (c *LRU[K, V]) Len() int { + if c == nil || c.size <= 0 { + return 0 + } + c.mu.Lock() + n := len(c.items) + c.mu.Unlock() + return n +} + +// Cap returns the maximum capacity of the cache. +func (c *LRU[K, V]) Cap() int { + if c == nil { + return 0 + } + return c.size +} + +// HitRate returns the cache hit ratio (0.0 to 1.0). +// Based on hits / (hits + misses). +func (c *LRU[K, V]) HitRate() float64 { + h := c.hits.Load() + m := c.misses.Load() + total := h + m + if total == 0 { + return 0.0 + } + return float64(h) / float64(total) +} + +// RemoveOldest removes and returns the least recently used item. +// Returns key, value, and true if an item was removed. +// Calls onEvict if set. +func (c *LRU[K, V]) RemoveOldest() (key K, value V, ok bool) { + if c == nil || c.size <= 0 { + return + } + c.mu.Lock() + defer c.mu.Unlock() + + if c.tail == nil { + return + } + + key = c.tail.key + value = c.tail.value + + c.removeOldest() + return key, value, true +} + +// moveToFront moves an entry to the front (MRU position). +func (c *LRU[K, V]) moveToFront(e *entry[K, V]) { + if c.head == e { + return + } + c.removeNode(e) + c.addToFront(e) +} + +// addToFront adds an entry to the front of the list. +func (c *LRU[K, V]) addToFront(e *entry[K, V]) { + e.prev = nil + e.next = c.head + if c.head != nil { + c.head.prev = e + } + c.head = e + if c.tail == nil { + c.tail = e + } + +} + +// removeNode removes an entry from the linked list. +func (c *LRU[K, V]) removeNode(e *entry[K, V]) { + if e.prev != nil { + e.prev.next = e.next + } else { + c.head = e.next + } + if e.next != nil { + e.next.prev = e.prev + } else { + c.tail = e.prev + } + e.prev = nil + e.next = nil +} + +// removeOldest removes the tail entry (LRU). +// Calls onEvict if set and deletes from map. +func (c *LRU[K, V]) removeOldest() { + if c.tail == nil { + return + } + e := c.tail + if c.onEvict != nil { + c.onEvict(e.key, e.value) + } + c.removeNode(e) + delete(c.items, e.key) +} diff --git a/vendor/github.com/olekukonko/tablewriter/pkg/twwarp/wrap.go b/vendor/github.com/olekukonko/tablewriter/pkg/twwarp/wrap.go index a577c1e..5977aac 100644 --- a/vendor/github.com/olekukonko/tablewriter/pkg/twwarp/wrap.go +++ b/vendor/github.com/olekukonko/tablewriter/pkg/twwarp/wrap.go @@ -12,8 +12,8 @@ import ( "strings" "unicode" + "github.com/clipperhouse/uax29/v2/graphemes" "github.com/olekukonko/tablewriter/pkg/twwidth" // IMPORT YOUR NEW PACKAGE - "github.com/rivo/uniseg" // "github.com/mattn/go-runewidth" // This can be removed if all direct uses are gone ) @@ -153,9 +153,9 @@ func stringToDisplayWidth(s string, targetWidth int) (substring string, actualWi var currentWidth int var endIndex int // Tracks the byte index in the original string - g := uniseg.NewGraphemes(s) + g := graphemes.FromString(s) for g.Next() { - grapheme := g.Str() + grapheme := g.Value() // graphemeWidth := runewidth.StringWidth(grapheme) // OLD graphemeWidth := twwidth.Width(grapheme) // NEW: Use twdw.Width @@ -164,8 +164,7 @@ func stringToDisplayWidth(s string, targetWidth int) (substring string, actualWi } currentWidth += graphemeWidth - _, e := g.Positions() - endIndex = e + endIndex = g.End() } return s[:endIndex], currentWidth } diff --git a/vendor/github.com/olekukonko/tablewriter/pkg/twwidth/width.go b/vendor/github.com/olekukonko/tablewriter/pkg/twwidth/width.go index 3b9634b..4afff74 100644 --- a/vendor/github.com/olekukonko/tablewriter/pkg/twwidth/width.go +++ b/vendor/github.com/olekukonko/tablewriter/pkg/twwidth/width.go @@ -6,32 +6,55 @@ import ( "strings" "sync" + "github.com/clipperhouse/displaywidth" "github.com/mattn/go-runewidth" + "github.com/olekukonko/tablewriter/pkg/twcache" ) -// condition holds the global runewidth configuration, including East Asian width settings. -var condition *runewidth.Condition +const ( + cacheCapacity = 8192 -// mu protects access to condition and widthCache for thread safety. + cachePrefix = "0:" + cacheEastAsianPrefix = "1:" +) + +// Options allows for configuring width calculation on a per-call basis. +type Options struct { + EastAsianWidth bool +} + +// globalOptions holds the global displaywidth configuration, including East Asian width settings. +var globalOptions Options + +// mu protects access to globalOptions for thread safety. var mu sync.Mutex +// widthCache stores memoized results of Width calculations to improve performance. +var widthCache *twcache.LRU[string, int] + // ansi is a compiled regular expression for stripping ANSI escape codes from strings. var ansi = Filter() func init() { - condition = runewidth.NewCondition() - widthCache = make(map[cacheKey]int) + // Initialize global options by detecting from the environment, + // which is the one key feature we get from go-runewidth. + cond := runewidth.NewCondition() + globalOptions = Options{ + EastAsianWidth: cond.EastAsianWidth, + } + widthCache = twcache.NewLRU[string, int](cacheCapacity) } -// cacheKey is used as a key for memoizing string width results in widthCache. -type cacheKey struct { - str string // Input string - eastAsianWidth bool // East Asian width setting +// makeCacheKey generates a string key for the LRU cache from the input string +// and the current East Asian width setting. +// Prefix "0:" for false, "1:" for true. +func makeCacheKey(str string, eastAsianWidth bool) string { + if eastAsianWidth { + return cacheEastAsianPrefix + str + } + return cachePrefix + str } -// widthCache stores memoized results of Width calculations to improve performance. -var widthCache map[cacheKey]int - // Filter compiles and returns a regular expression for matching ANSI escape sequences, // including CSI (Control Sequence Introducer) and OSC (Operating System Command) sequences. // The returned regex can be used to strip ANSI codes from strings. @@ -50,99 +73,102 @@ func Filter() *regexp.Regexp { return regexp.MustCompile("(" + regCSI + "|" + regOSC + ")") } -// SetEastAsian enables or disables East Asian width handling for width calculations. -// When the setting changes, the width cache is cleared to ensure accuracy. +// SetOptions sets the global options for width calculation. +// This function is thread-safe. +func SetOptions(opts Options) { + mu.Lock() + defer mu.Unlock() + if globalOptions.EastAsianWidth != opts.EastAsianWidth { + globalOptions = opts + widthCache.Purge() + } +} + +// SetEastAsian enables or disables East Asian width handling globally. // This function is thread-safe. // // Example: // // twdw.SetEastAsian(true) // Enable East Asian width handling func SetEastAsian(enable bool) { - mu.Lock() - defer mu.Unlock() - if condition.EastAsianWidth != enable { - condition.EastAsianWidth = enable - widthCache = make(map[cacheKey]int) // Clear cache on setting change - } + SetOptions(Options{EastAsianWidth: enable}) } -// SetCondition updates the global runewidth.Condition used for width calculations. -// When the condition is changed, the width cache is cleared. +// IsEastAsian returns the current East Asian width setting. // This function is thread-safe. // // Example: // -// newCond := runewidth.NewCondition() -// newCond.EastAsianWidth = true -// twdw.SetCondition(newCond) -func SetCondition(newCond *runewidth.Condition) { +// if twdw.IsEastAsian() { +// // Handle East Asian width characters +// } +func IsEastAsian() bool { mu.Lock() defer mu.Unlock() - condition = newCond - widthCache = make(map[cacheKey]int) // Clear cache on setting change + return globalOptions.EastAsianWidth } -// Width calculates the visual width of a string, excluding ANSI escape sequences, -// using the go-runewidth package for accurate Unicode handling. It accounts for the -// current East Asian width setting and caches results for performance. +// Deprecated: use SetOptions with the new twwidth.Options struct instead. +// This function is kept for backward compatibility. +func SetCondition(cond *runewidth.Condition) { + mu.Lock() + defer mu.Unlock() + newEastAsianWidth := cond.EastAsianWidth + if globalOptions.EastAsianWidth != newEastAsianWidth { + globalOptions.EastAsianWidth = newEastAsianWidth + widthCache.Purge() + } +} + +// Width calculates the visual width of a string using the global cache for performance. +// It excludes ANSI escape sequences and accounts for the global East Asian width setting. // This function is thread-safe. // // Example: // // width := twdw.Width("Hello\x1b[31mWorld") // Returns 10 func Width(str string) int { - mu.Lock() - key := cacheKey{str: str, eastAsianWidth: condition.EastAsianWidth} - if w, found := widthCache[key]; found { - mu.Unlock() + currentEA := IsEastAsian() + key := makeCacheKey(str, currentEA) + + if w, found := widthCache.Get(key); found { return w } - mu.Unlock() - - // Use a temporary condition to avoid holding the lock during calculation - tempCond := runewidth.NewCondition() - tempCond.EastAsianWidth = key.eastAsianWidth + opts := displaywidth.Options{EastAsianWidth: currentEA} stripped := ansi.ReplaceAllLiteralString(str, "") - calculatedWidth := tempCond.StringWidth(stripped) - - mu.Lock() - widthCache[key] = calculatedWidth - mu.Unlock() + calculatedWidth := opts.String(stripped) + widthCache.Add(key, calculatedWidth) return calculatedWidth } -// WidthNoCache calculates the visual width of a string without using or -// updating the global cache. It uses the current global East Asian width setting. -// This function is intended for internal use (e.g., benchmarking) and is thread-safe. +// WidthWithOptions calculates the visual width of a string with specific options, +// bypassing the global settings and cache. This is useful for one-shot calculations +// where global state is not desired. +func WidthWithOptions(str string, opts Options) int { + dwOpts := displaywidth.Options{EastAsianWidth: opts.EastAsianWidth} + stripped := ansi.ReplaceAllLiteralString(str, "") + return dwOpts.String(stripped) +} + +// WidthNoCache calculates the visual width of a string without using the global cache. // // Example: // // width := twdw.WidthNoCache("Hello\x1b[31mWorld") // Returns 10 func WidthNoCache(str string) int { - mu.Lock() - currentEA := condition.EastAsianWidth - mu.Unlock() - - tempCond := runewidth.NewCondition() - tempCond.EastAsianWidth = currentEA - - stripped := ansi.ReplaceAllLiteralString(str, "") - return tempCond.StringWidth(stripped) + // This function's behavior is equivalent to a one-shot calculation + // using the current global options. The WidthWithOptions function + // does not interact with the cache, thus fulfilling the requirement. + return WidthWithOptions(str, Options{EastAsianWidth: IsEastAsian()}) } -// Display calculates the visual width of a string, excluding ANSI escape sequences, -// using the provided runewidth condition. Unlike Width, it does not use caching -// and is intended for cases where a specific condition is required. -// This function is thread-safe with respect to the provided condition. -// -// Example: -// -// cond := runewidth.NewCondition() -// width := twdw.Display(cond, "Hello\x1b[31mWorld") // Returns 10 +// Deprecated: use WidthWithOptions with the new twwidth.Options struct instead. +// This function is kept for backward compatibility. func Display(cond *runewidth.Condition, str string) int { - return cond.StringWidth(ansi.ReplaceAllLiteralString(str, "")) + opts := Options{EastAsianWidth: cond.EastAsianWidth} + return WidthWithOptions(str, opts) } // Truncate shortens a string to fit within a specified visual width, optionally @@ -189,31 +215,34 @@ func Truncate(s string, maxWidth int, suffix ...string) string { // Case 3: String fits completely or fits with suffix. // Here, maxWidth is the total budget for the line. if sDisplayWidth <= maxWidth { + // If the string contains ANSI, we must ensure it ends with a reset + // to prevent bleeding, even if we don't truncate. + safeS := s + if strings.Contains(s, "\x1b") && !strings.HasSuffix(s, "\x1b[0m") { + safeS += "\x1b[0m" + } + if len(suffixStr) == 0 { // No suffix. - return s + return safeS } // Suffix is provided. Check if s + suffix fits. if sDisplayWidth+suffixDisplayWidth <= maxWidth { - return s + suffixStr + return safeS + suffixStr } - // s fits, but s + suffix is too long. Return s. - return s + // s fits, but s + suffix is too long. Return s (with reset if needed). + return safeS } // Case 4: String needs truncation (sDisplayWidth > maxWidth). // maxWidth is the total budget for the final string (content + suffix). - - // Capture the global EastAsianWidth setting once for consistent use - mu.Lock() - currentGlobalEastAsianWidth := condition.EastAsianWidth - mu.Unlock() + currentGlobalEastAsianWidth := IsEastAsian() // Special case for EastAsian true: if only suffix fits, return suffix. // This was derived from previous test behavior. if len(suffixStr) > 0 && currentGlobalEastAsianWidth { provisionalContentWidth := maxWidth - suffixDisplayWidth if provisionalContentWidth == 0 { // Exactly enough space for suffix only - return suffixStr // <<<< MODIFIED: No ANSI reset here + return suffixStr } } @@ -235,7 +264,6 @@ func Truncate(s string, maxWidth int, suffix ...string) string { } return "" // Cannot fit anything. } - // If targetContentForIteration is 0, loop won't run, result will be empty string, then suffix is added. var contentBuf bytes.Buffer var currentContentDisplayWidth int @@ -243,8 +271,7 @@ func Truncate(s string, maxWidth int, suffix ...string) string { inAnsiSequence := false ansiWrittenToContent := false - localRunewidthCond := runewidth.NewCondition() - localRunewidthCond.EastAsianWidth = currentGlobalEastAsianWidth + dwOpts := displaywidth.Options{EastAsianWidth: currentGlobalEastAsianWidth} for _, r := range s { if r == '\x1b' { @@ -278,7 +305,7 @@ func Truncate(s string, maxWidth int, suffix ...string) string { ansiSeqBuf.Reset() } } else { // Normal character - runeDisplayWidth := localRunewidthCond.RuneWidth(r) + runeDisplayWidth := dwOpts.Rune(r) if targetContentForIteration == 0 { // No budget for content at all break } @@ -292,32 +319,51 @@ func Truncate(s string, maxWidth int, suffix ...string) string { result := contentBuf.String() - // Suffix is added if: - // 1. A suffix string is provided. - // 2. Truncation actually happened (sDisplayWidth > maxWidth originally) - // OR if the content part is empty but a suffix is meant to be shown - // (e.g. targetContentForIteration was 0). - if len(suffixStr) > 0 { - // Add suffix if we are in the truncation path (sDisplayWidth > maxWidth) - // OR if targetContentForIteration was 0 (meaning only suffix should be shown) - // but we must ensure we don't exceed original maxWidth. - // The logic above for targetContentForIteration already ensures space. - - needsReset := false - // Condition for reset: if styling was active in 's' and might affect suffix - if (ansiWrittenToContent || (inAnsiSequence && strings.Contains(s, "\x1b["))) && (currentContentDisplayWidth > 0 || ansiWrittenToContent) { - if !strings.HasSuffix(result, "\x1b[0m") { - needsReset = true - } - } else if currentContentDisplayWidth > 0 && strings.Contains(result, "\x1b[") && !strings.HasSuffix(result, "\x1b[0m") && strings.Contains(s, "\x1b[") { - // If result has content and ANSI, and original had ANSI, and result not already reset + // Determine if we need to append a reset sequence to prevent color bleeding. + // This is needed if we wrote any ANSI codes or if the input had active codes + // that we might have cut off or left open. + needsReset := false + if (ansiWrittenToContent || (inAnsiSequence && strings.Contains(s, "\x1b["))) && (currentContentDisplayWidth > 0 || ansiWrittenToContent) { + if !strings.HasSuffix(result, "\x1b[0m") { needsReset = true } + } else if currentContentDisplayWidth > 0 && strings.Contains(result, "\x1b[") && !strings.HasSuffix(result, "\x1b[0m") && strings.Contains(s, "\x1b[") { + needsReset = true + } - if needsReset { - result += "\x1b[0m" - } + if needsReset { + result += "\x1b[0m" + } + + // Suffix is added if provided. + if len(suffixStr) > 0 { result += suffixStr } return result } + +// SetCacheCapacity changes the cache size dynamically +// If capacity <= 0, disables caching entirely +func SetCacheCapacity(capacity int) { + mu.Lock() + defer mu.Unlock() + + if capacity <= 0 { + widthCache = nil // nil = fully disabled + return + } + + newCache := twcache.NewLRU[string, int](capacity) + widthCache = newCache +} + +// GetCacheStats returns current cache statistics +func GetCacheStats() (size, capacity int, hitRate float64) { + mu.Lock() + defer mu.Unlock() + + if widthCache == nil { + return 0, 0, 0 + } + return widthCache.Len(), widthCache.Cap(), widthCache.HitRate() +} diff --git a/vendor/github.com/olekukonko/tablewriter/tablewriter.go b/vendor/github.com/olekukonko/tablewriter/tablewriter.go index b15d150..464324a 100644 --- a/vendor/github.com/olekukonko/tablewriter/tablewriter.go +++ b/vendor/github.com/olekukonko/tablewriter/tablewriter.go @@ -8,11 +8,11 @@ import ( "reflect" "runtime" "strings" - "sync" "github.com/olekukonko/errors" "github.com/olekukonko/ll" "github.com/olekukonko/ll/lh" + "github.com/olekukonko/tablewriter/pkg/twcache" "github.com/olekukonko/tablewriter/pkg/twwarp" "github.com/olekukonko/tablewriter/pkg/twwidth" "github.com/olekukonko/tablewriter/renderer" @@ -23,7 +23,7 @@ import ( type Table struct { writer io.Writer // Destination for table output counters []tw.Counter // Counters for indices - rows [][][]string // Row data, supporting multi-line cells + rows [][]string // Row data, one slice of strings per logical row headers [][]string // Header content footers [][]string // Footer content headerWidths tw.Mapper[int, int] // Computed widths for header columns @@ -52,9 +52,7 @@ type Table struct { streamRowCounter int // Counter for rows rendered in streaming mode (0-indexed logical rows) // cache - stringerCache map[reflect.Type]reflect.Value // Cache for stringer reflection - stringerCacheMu sync.RWMutex // Mutex for thread-safe cache access - stringerCacheEnabled bool // Flag to enable/disable caching + stringerCache twcache.Cache[reflect.Type, reflect.Value] // Cache for stringer reflection batchRenderNumCols int isBatchRenderNumColsSet bool @@ -126,8 +124,7 @@ func NewTable(w io.Writer, opts ...Option) *Table { streamRowCounter: 0, // Cache - stringerCache: make(map[reflect.Type]reflect.Value), - stringerCacheEnabled: false, // Disabled by default + stringerCache: twcache.NewLRU[reflect.Type, reflect.Value](tw.DefaultCacheStringCapacity), } // set Options @@ -221,13 +218,12 @@ func (t *Table) Append(rows ...interface{}) error { } } - // The rest of the function proceeds as before, converting the data to string lines. - lines, err := t.toStringLines(cellsSource, t.config.Row) + cells, err := t.convertCellsToStrings(cellsSource, t.config.Row) if err != nil { t.logger.Errorf("Append (Batch) failed for cellsSource %v: %v", cellsSource, err) return err } - t.rows = append(t.rows, lines) + t.rows = append(t.rows, cells) t.logger.Debugf("Append (Batch) completed for one row, total rows in table: %d", len(t.rows)) return nil @@ -456,7 +452,7 @@ func (t *Table) Reset() { t.logger.Debug("Reset() called. Clearing table data and render state.") // Clear data slices - t.rows = nil // Or t.rows = make([][][]string, 0) + t.rows = nil // Or t.rows = make([][]string, 0) t.headers = nil // Or t.headers = make([][]string, 0) t.footers = nil // Or t.footers = make([][]string, 0) @@ -484,10 +480,11 @@ func (t *Table) Reset() { t.streamRowCounter = 0 // The stringer and its cache are part of the table's configuration, - if t.stringerCacheEnabled { - t.stringerCacheMu.Lock() - t.stringerCache = make(map[reflect.Type]reflect.Value) - t.stringerCacheMu.Unlock() + if t.stringerCache == nil { + t.stringerCache = twcache.NewLRU[reflect.Type, reflect.Value](tw.DefaultCacheStringCapacity) + t.logger.Debug("Reset(): Stringer cache reset to default capacity.") + } else { + t.stringerCache.Purge() t.logger.Debug("Reset(): Stringer cache cleared.") } @@ -556,16 +553,14 @@ func (t *Table) appendSingle(row interface{}) error { t.logger.Debugf("appendSingle: Dispatching to streamAppendRow for row: %v", row) return t.streamAppendRow(row) // Call the streaming render function } - // Existing batch logic: + t.logger.Debugf("appendSingle: Processing for batch mode, row: %v", row) - // toStringLines now uses the new convertCellsToStrings internally, then prepareContent. - // This is fine for batch. - lines, err := t.toStringLines(row, t.config.Row) + cells, err := t.convertCellsToStrings(row, t.config.Row) if err != nil { - t.logger.Debugf("Error in toStringLines (batch mode): %v", err) + t.logger.Debugf("Error in convertCellsToStrings (batch mode): %v", err) return err } - t.rows = append(t.rows, lines) // Add to batch storage + t.rows = append(t.rows, cells) // Add to batch storage t.logger.Debugf("Row appended to batch t.rows, total batch rows: %d", len(t.rows)) return nil } @@ -775,8 +770,8 @@ func (t *Table) maxColumns() int { m = len(t.headers[0]) } for _, row := range t.rows { - if len(row) > 0 && len(row[0]) > m { - m = len(row[0]) + if len(row) > m { + m = len(row) } } if len(t.footers) > 0 && len(t.footers[0]) > m { @@ -811,7 +806,7 @@ func (t *Table) printTopBottomCaption(w io.Writer, actualTableWidth int) { t.logger.Debugf("[printCaption] Empty table, no user caption.Width: Using natural caption width %d.", captionWrapWidth) } else { captionWrapWidth = actualTableWidth - t.logger.Debugf("[printCaption] Non-empty table, no user caption.Width: Using actualTableWidth %d for wrapping.", actualTableWidth) + t.logger.Debugf("[printCaption] Non-empty table, no user caption.Width: Using actualTableWidth %d for wrapping.", captionWrapWidth) } if captionWrapWidth <= 0 { @@ -1066,13 +1061,20 @@ func (t *Table) prepareContexts() (*renderContext, *mergeContext, error) { logger: t.logger, } - isEmpty, visibleCount := t.getEmptyColumnInfo(numOriginalCols) + // Process raw rows into visual, multi-line rows + processedRowLines := make([][][]string, len(t.rows)) + for i, rawRow := range t.rows { + processedRowLines[i] = t.prepareContent(rawRow, t.config.Row) + } + ctx.rowLines = processedRowLines + + isEmpty, visibleCount := t.getEmptyColumnInfo(ctx.rowLines, numOriginalCols) ctx.emptyColumns = isEmpty ctx.visibleColCount = visibleCount mctx := &mergeContext{ headerMerges: make(map[int]tw.MergeState), - rowMerges: make([]map[int]tw.MergeState, len(t.rows)), + rowMerges: make([]map[int]tw.MergeState, len(ctx.rowLines)), footerMerges: make(map[int]tw.MergeState), horzMerges: make(map[tw.Position]map[int]bool), } @@ -1081,7 +1083,6 @@ func (t *Table) prepareContexts() (*renderContext, *mergeContext, error) { } ctx.headerLines = t.headers - ctx.rowLines = t.rows ctx.footerLines = t.footers if err := t.calculateAndNormalizeWidths(ctx); err != nil { @@ -1095,21 +1096,28 @@ func (t *Table) prepareContexts() (*renderContext, *mergeContext, error) { ctx.headerLines = preparedHeaderLines mctx.headerMerges = headerMerges - processedRowLines := make([][][]string, len(ctx.rowLines)) + // Re-process row lines for merges now that widths are known + processedRowLinesWithMerges := make([][][]string, len(ctx.rowLines)) for i, row := range ctx.rowLines { if mctx.rowMerges[i] == nil { mctx.rowMerges[i] = make(map[int]tw.MergeState) } - processedRowLines[i], mctx.rowMerges[i], _ = t.prepareWithMerges(row, t.config.Row, tw.Row) + processedRowLinesWithMerges[i], mctx.rowMerges[i], _ = t.prepareWithMerges(row, t.config.Row, tw.Row) } - ctx.rowLines = processedRowLines + ctx.rowLines = processedRowLinesWithMerges - t.applyHorizontalMergeWidths(tw.Header, ctx, mctx.headerMerges) + t.applyHorizontalMerges(tw.Header, ctx, mctx.headerMerges) - if t.config.Row.Formatting.MergeMode&tw.MergeVertical != 0 { + mergeMode := t.config.Row.Merging.Mode + if mergeMode == 0 { + mergeMode = t.config.Row.Formatting.MergeMode + } + + // Now check against the effective mode + if mergeMode&tw.MergeVertical != 0 { t.applyVerticalMerges(ctx, mctx) } - if t.config.Row.Formatting.MergeMode&tw.MergeHierarchical != 0 { + if mergeMode&tw.MergeHierarchical != 0 { t.applyHierarchicalMerges(ctx, mctx) } @@ -1166,7 +1174,7 @@ func (t *Table) prepareFooter(ctx *renderContext, mctx *mergeContext) { mctx.footerMerges = mergeStates ctx.footerLines = t.footers t.logger.Debugf("Base footer widths (normalized from rows/header): %v", ctx.widths[tw.Footer]) - t.applyHorizontalMergeWidths(tw.Footer, ctx, mctx.footerMerges) + t.applyHorizontalMerges(tw.Footer, ctx, mctx.footerMerges) ctx.footerPrepared = true t.logger.Debugf("Footer preparation completed. Final footer widths: %v", ctx.widths[tw.Footer]) } diff --git a/vendor/github.com/olekukonko/tablewriter/tw/cell.go b/vendor/github.com/olekukonko/tablewriter/tw/cell.go index 47f0962..19f6775 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/cell.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/cell.go @@ -2,16 +2,31 @@ package tw // CellFormatting holds formatting options for table cells. type CellFormatting struct { - AutoWrap int // Wrapping behavior (e.g., WrapTruncate, WrapNormal) - MergeMode int // Bitmask for merge behavior (e.g., MergeHorizontal, MergeVertical) - - // Changed form bool to State - // See https://github.com/olekukonko/tablewriter/issues/261 + AutoWrap int // Wrapping behavior (e.g., WrapTruncate, WrapNormal) AutoFormat State // Enables automatic formatting (e.g., title case for headers) - // Deprecated: kept for compatibility - // will be removed soon - Alignment Align // Text alignment within the cell (e.g., Left, Right, Center) + // Deprecated: Kept for backward compatibility. Use CellConfig.CellMerging.Mode instead. + // This will be removed in a future version. + MergeMode int + + // Deprecated: Kept for backward compatibility. Use CellConfig.Alignment instead. + // This will be removed in a future version. + Alignment Align +} + +// CellMerging holds the configuration for how cells should be merged. +// This new struct replaces the deprecated MergeMode. +type CellMerging struct { + // Mode is a bitmask specifying the type of merge (e.g., MergeHorizontal, MergeVertical). + Mode int + + // ByColumnIndex specifies which column indices should be considered for merging. + // If the mapper is nil or empty, merging applies to all columns (if Mode is set). + // Otherwise, only columns with an index present as a key will be merged. + ByColumnIndex Mapper[int, bool] + + // ByRowIndex is reserved for future features to specify merging on specific rows. + ByRowIndex Mapper[int, bool] } // CellPadding defines padding settings for table cells. @@ -47,6 +62,7 @@ type CellConfig struct { Filter CellFilter // Function to filter cell content (renamed from Filter Filter) Alignment CellAlignment // Alignment configuration for cells ColMaxWidths CellWidth // Per-column maximum width overrides + Merging CellMerging // Merging holds all configuration related to cell merging. // Deprecated: use Alignment.PerColumn instead. Will be removed in a future version. // will be removed soon diff --git a/vendor/github.com/olekukonko/tablewriter/tw/mapper.go b/vendor/github.com/olekukonko/tablewriter/tw/mapper.go index 058d358..1eee9eb 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/mapper.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/mapper.go @@ -210,3 +210,36 @@ func (m Mapper[K, V]) SortedKeys() []K { return keys } + +func NewBoolMapper[K comparable](keys ...K) Mapper[K, bool] { + if len(keys) == 0 { + return nil + } + mapper := NewMapper[K, bool]() + for _, key := range keys { + mapper.Set(key, true) + } + return mapper +} + +func NewIntMapper[K comparable](keys ...K) Mapper[K, int] { + if len(keys) == 0 { + return nil + } + mapper := NewMapper[K, int]() + for _, key := range keys { + mapper.Set(key, 0) + } + return mapper +} + +func NewIdentityMapper[K comparable](keys ...K) Mapper[K, K] { + if len(keys) == 0 { + return nil + } + mapper := NewMapper[K, K]() + for _, key := range keys { + mapper.Set(key, key) + } + return mapper +} diff --git a/vendor/github.com/olekukonko/tablewriter/tw/tw.go b/vendor/github.com/olekukonko/tablewriter/tw/tw.go index f1cbb9e..8afde08 100644 --- a/vendor/github.com/olekukonko/tablewriter/tw/tw.go +++ b/vendor/github.com/olekukonko/tablewriter/tw/tw.go @@ -8,6 +8,8 @@ const ( Success = 1 // Operation succeeded MinimumColumnWidth = 8 + + DefaultCacheStringCapacity = 10 * 1024 // 10 KB ) const ( diff --git a/vendor/github.com/olekukonko/tablewriter/zoo.go b/vendor/github.com/olekukonko/tablewriter/zoo.go index 4c514e9..b11c4b7 100644 --- a/vendor/github.com/olekukonko/tablewriter/zoo.go +++ b/vendor/github.com/olekukonko/tablewriter/zoo.go @@ -18,7 +18,23 @@ import ( // Parameters ctx and mctx hold rendering and merge state. // No return value. func (t *Table) applyHierarchicalMerges(ctx *renderContext, mctx *mergeContext) { - ctx.logger.Debug("Applying hierarchical merges (left-to-right vertical flow - snapshot comparison)") + // First, ensure we should even run this logic. + // Check both the new CellMerging struct and the deprecated Formatting field. + mergeMode := t.config.Row.Merging.Mode + if mergeMode == 0 { + mergeMode = t.config.Row.Formatting.MergeMode + } + if !(mergeMode&tw.MergeHierarchical != 0) { + return + } + + mergeColumnMapper := t.config.Row.Merging.ByColumnIndex + if mergeColumnMapper != nil { + ctx.logger.Debugf("Applying hierarchical merges ONLY to specified columns: %v", mergeColumnMapper.Keys()) + } else { + ctx.logger.Debug("Applying hierarchical merges (left-to-right vertical flow - snapshot comparison)") + } + if len(ctx.rowLines) <= 1 { ctx.logger.Debug("Skipping hierarchical merges - less than 2 rows") return @@ -41,6 +57,12 @@ func (t *Table) applyHierarchicalMerges(ctx *renderContext, mctx *mergeContext) leftCellContinuedHierarchical := false for c := 0; c < numCols; c++ { + // If a column map is specified, skip columns that are not in it. + if mergeColumnMapper != nil && !mergeColumnMapper.Has(c) { + leftCellContinuedHierarchical = false // Reset hierarchy tracking + continue + } + if mctx.rowMerges[r] == nil { mctx.rowMerges[r] = make(map[int]tw.MergeState) } @@ -146,15 +168,15 @@ func (t *Table) applyHierarchicalMerges(ctx *renderContext, mctx *mergeContext) ctx.logger.Debug("Hierarchical merge processing completed") } -// applyHorizontalMergeWidths adjusts column widths for horizontal merges. +// applyHorizontalMerges adjusts column widths for horizontal merges. // Parameters include position, ctx for rendering, and mergeStates for merges. // No return value. -func (t *Table) applyHorizontalMergeWidths(position tw.Position, ctx *renderContext, mergeStates map[int]tw.MergeState) { +func (t *Table) applyHorizontalMerges(position tw.Position, ctx *renderContext, mergeStates map[int]tw.MergeState) { if mergeStates == nil { - t.logger.Debugf("applyHorizontalMergeWidths: Skipping %s - no merge states", position) + t.logger.Debugf("applyHorizontalMerges: Skipping %s - no merge states", position) return } - t.logger.Debugf("applyHorizontalMergeWidths: Applying HMerge width recalc for %s", position) + t.logger.Debugf("applyHorizontalMerges: Applying HMerge width recalc for %s", position) numCols := ctx.numCols targetWidthsMap := ctx.widths[position] @@ -211,16 +233,31 @@ func (t *Table) applyHorizontalMergeWidths(position tw.Position, ctx *renderCont } } } - ctx.logger.Debugf("applyHorizontalMergeWidths: Final widths for %s: %v", position, targetWidthsMap) + ctx.logger.Debugf("applyHorizontalMerges: Final widths for %s: %v", position, targetWidthsMap) } // applyVerticalMerges applies vertical merges to row content. // Parameters ctx and mctx hold rendering and merge state. // No return value. func (t *Table) applyVerticalMerges(ctx *renderContext, mctx *mergeContext) { - ctx.logger.Debugf("Applying vertical merges across %d rows", len(ctx.rowLines)) - numCols := ctx.numCols + // First, ensure we should even run this logic. + // Check both the new CellMerging struct and the deprecated Formatting field. + mergeMode := t.config.Row.Merging.Mode + if mergeMode == 0 { + mergeMode = t.config.Row.Formatting.MergeMode + } + if !(mergeMode&tw.MergeVertical != 0) { + return + } + mergeColumnMapper := t.config.Row.Merging.ByColumnIndex + if mergeColumnMapper != nil { + ctx.logger.Debugf("Applying vertical merges ONLY to specified columns: %v", mergeColumnMapper.Keys()) + } else { + ctx.logger.Debugf("Applying vertical merges across %d rows", len(ctx.rowLines)) + } + + numCols := ctx.numCols mergeStartRow := make(map[int]int) mergeStartContent := make(map[int]string) @@ -243,6 +280,11 @@ func (t *Table) applyVerticalMerges(ctx *renderContext, mctx *mergeContext) { currentLineContent := ctx.rowLines[i] for col := 0; col < numCols; col++ { + // If a column map is specified, skip columns that are not in it. + if mergeColumnMapper != nil && !mergeColumnMapper.Has(col) { + continue + } + // Join all lines of the cell to compare full content var currentVal strings.Builder for _, line := range currentLineContent { @@ -579,11 +621,6 @@ func (t *Table) calculateAndNormalizeWidths(ctx *renderContext) error { ctx.logger.Debugf("calculateAndNormalizeWidths: Computing and normalizing widths for %d columns. Compact: %v", ctx.numCols, t.config.Behavior.Compact.Merge.Enabled()) - // Initialize width maps - // t.headerWidths = tw.NewMapper[int, int]() - // t.rowWidths = tw.NewMapper[int, int]() - // t.footerWidths = tw.NewMapper[int, int]() - // Compute content-based widths for each section for _, lines := range ctx.headerLines { t.updateWidths(lines, t.headerWidths, t.config.Header.Padding) @@ -1027,17 +1064,13 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { t.logger.Debugf("convertToString attempt %v using %v", input, t.stringer) inputType := reflect.TypeOf(input) - stringerFuncVal := reflect.ValueOf(t.stringer) - stringerFuncType := stringerFuncVal.Type() - // Cache lookup (simplified, actual cache logic can be more complex) - if t.stringerCacheEnabled { - t.stringerCacheMu.RLock() - cachedFunc, ok := t.stringerCache[inputType] - t.stringerCacheMu.RUnlock() - if ok { - // Add proper type checking for cachedFunc against input here if necessary + // Cache lookup using twcache.LRU + // This assumes t.stringerCache is *twcache.LRU[reflect.Type, reflect.Value] + if t.stringerCache != nil { + if cachedFunc, ok := t.stringerCache.Get(inputType); ok { t.logger.Debugf("convertToStringer: Cache hit for type %v", inputType) + // We can proceed to call it immediately because it's already been validated/cached results := cachedFunc.Call([]reflect.Value{reflect.ValueOf(input)}) if len(results) == 1 && results[0].Type() == reflect.TypeOf([]string{}) { return results[0].Interface().([]string), nil @@ -1045,6 +1078,9 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { } } + stringerFuncVal := reflect.ValueOf(t.stringer) + stringerFuncType := stringerFuncVal.Type() + // Robust type checking for the stringer function validSignature := stringerFuncVal.Kind() == reflect.Func && stringerFuncType.NumIn() == 1 && @@ -1068,10 +1104,6 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { } } else if paramType.Kind() == reflect.Interface || (paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() != reflect.Interface) { // If input is nil, it can be assigned if stringer expects an interface or a pointer type - // (but not a pointer to an interface, which is rare for stringers). - // A nil value for a concrete type parameter would cause a panic on Call. - // So, if paramType is not an interface/pointer, and input is nil, it's an issue. - // This needs careful handling. For now, assume assignable if interface/pointer. assignable = true } @@ -1083,7 +1115,6 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { if input == nil { // If input is nil, we must pass a zero value of the stringer's parameter type // if that type is a pointer or interface. - // Passing reflect.ValueOf(nil) directly will cause issues if paramType is concrete. callArgs = []reflect.Value{reflect.Zero(paramType)} } else { callArgs = []reflect.Value{reflect.ValueOf(input)} @@ -1091,10 +1122,9 @@ func (t *Table) convertToStringer(input interface{}) ([]string, error) { resultValues := stringerFuncVal.Call(callArgs) - if t.stringerCacheEnabled && inputType != nil { // Only cache if inputType is valid - t.stringerCacheMu.Lock() - t.stringerCache[inputType] = stringerFuncVal - t.stringerCacheMu.Unlock() + // Add to cache if enabled (not nil) and input type is valid + if t.stringerCache != nil && inputType != nil { + t.stringerCache.Add(inputType, stringerFuncVal) } return resultValues[0].Interface().([]string), nil @@ -1438,7 +1468,7 @@ func (t *Table) getColMaxWidths(position tw.Position) tw.CellWidth { // getEmptyColumnInfo identifies empty columns in row data. // Parameter numOriginalCols specifies the total column count. // Returns a boolean slice (true for empty) and visible column count. -func (t *Table) getEmptyColumnInfo(numOriginalCols int) (isEmpty []bool, visibleColCount int) { +func (t *Table) getEmptyColumnInfo(processedRows [][][]string, numOriginalCols int) (isEmpty []bool, visibleColCount int) { isEmpty = make([]bool, numOriginalCols) for i := range isEmpty { isEmpty[i] = true @@ -1453,9 +1483,9 @@ func (t *Table) getEmptyColumnInfo(numOriginalCols int) (isEmpty []bool, visible return isEmpty, visibleColCount } - t.logger.Debugf("getEmptyColumnInfo: Checking %d rows for %d columns...", len(t.rows), numOriginalCols) + t.logger.Debugf("getEmptyColumnInfo: Checking %d rows for %d columns...", len(processedRows), numOriginalCols) - for rowIdx, logicalRow := range t.rows { + for rowIdx, logicalRow := range processedRows { for lineIdx, visualLine := range logicalRow { for colIdx, cellContent := range visualLine { if colIdx >= numOriginalCols { @@ -1567,15 +1597,6 @@ func (t *Table) processVariadic(elements []any) []any { return elements } -// toStringLines converts raw cells to formatted lines for table output -func (t *Table) toStringLines(row any, config tw.CellConfig) ([][]string, error) { - cells, err := t.convertCellsToStrings(row, config) - if err != nil { - return nil, err - } - return t.prepareContent(cells, config), nil -} - // updateWidths updates the width map based on cell content and padding. // Parameters include row content, widths map, and padding configuration. // No return value. @@ -1598,10 +1619,9 @@ func (t *Table) updateWidths(row []string, widths tw.Mapper[int, int], padding t lines := strings.Split(cell, tw.NewLine) contentWidth := 0 for _, line := range lines { + // Always measure the raw line width, because the renderer + // will receive the raw line. Do not trim before measuring. lineWidth := twwidth.Width(line) - if t.config.Behavior.TrimSpace.Enabled() { - lineWidth = twwidth.Width(t.Trimmer(line)) - } if lineWidth > contentWidth { contentWidth = lineWidth } diff --git a/vendor/github.com/rivo/uniseg/README.md b/vendor/github.com/rivo/uniseg/README.md deleted file mode 100644 index a8191b8..0000000 --- a/vendor/github.com/rivo/uniseg/README.md +++ /dev/null @@ -1,137 +0,0 @@ -# Unicode Text Segmentation for Go - -[![Go Reference](https://pkg.go.dev/badge/github.com/rivo/uniseg.svg)](https://pkg.go.dev/github.com/rivo/uniseg) -[![Go Report](https://img.shields.io/badge/go%20report-A%2B-brightgreen.svg)](https://goreportcard.com/report/github.com/rivo/uniseg) - -This Go package implements Unicode Text Segmentation according to [Unicode Standard Annex #29](https://unicode.org/reports/tr29/), Unicode Line Breaking according to [Unicode Standard Annex #14](https://unicode.org/reports/tr14/) (Unicode version 15.0.0), and monospace font string width calculation similar to [wcwidth](https://man7.org/linux/man-pages/man3/wcwidth.3.html). - -## Background - -### Grapheme Clusters - -In Go, [strings are read-only slices of bytes](https://go.dev/blog/strings). They can be turned into Unicode code points using the `for` loop or by casting: `[]rune(str)`. However, multiple code points may be combined into one user-perceived character or what the Unicode specification calls "grapheme cluster". Here are some examples: - -|String|Bytes (UTF-8)|Code points (runes)|Grapheme clusters| -|-|-|-|-| -|Käse|6 bytes: `4b 61 cc 88 73 65`|5 code points: `4b 61 308 73 65`|4 clusters: `[4b],[61 308],[73],[65]`| -|🏳️‍🌈|14 bytes: `f0 9f 8f b3 ef b8 8f e2 80 8d f0 9f 8c 88`|4 code points: `1f3f3 fe0f 200d 1f308`|1 cluster: `[1f3f3 fe0f 200d 1f308]`| -|🇩🇪|8 bytes: `f0 9f 87 a9 f0 9f 87 aa`|2 code points: `1f1e9 1f1ea`|1 cluster: `[1f1e9 1f1ea]`| - -This package provides tools to iterate over these grapheme clusters. This may be used to determine the number of user-perceived characters, to split strings in their intended places, or to extract individual characters which form a unit. - -### Word Boundaries - -Word boundaries are used in a number of different contexts. The most familiar ones are selection (double-click mouse selection), cursor movement ("move to next word" control-arrow keys), and the dialog option "Whole Word Search" for search and replace. They are also used in database queries, to determine whether elements are within a certain number of words of one another. Searching may also use word boundaries in determining matching items. This package provides tools to determine word boundaries within strings. - -### Sentence Boundaries - -Sentence boundaries are often used for triple-click or some other method of selecting or iterating through blocks of text that are larger than single words. They are also used to determine whether words occur within the same sentence in database queries. This package provides tools to determine sentence boundaries within strings. - -### Line Breaking - -Line breaking, also known as word wrapping, is the process of breaking a section of text into lines such that it will fit in the available width of a page, window or other display area. This package provides tools to determine where a string may or may not be broken and where it must be broken (for example after newline characters). - -### Monospace Width - -Most terminals or text displays / text editors using a monospace font (for example source code editors) use a fixed width for each character. Some characters such as emojis or characters found in Asian and other languages may take up more than one character cell. This package provides tools to determine the number of cells a string will take up when displayed in a monospace font. See [here](https://pkg.go.dev/github.com/rivo/uniseg#hdr-Monospace_Width) for more information. - -## Installation - -```bash -go get github.com/rivo/uniseg -``` - -## Examples - -### Counting Characters in a String - -```go -n := uniseg.GraphemeClusterCount("🇩🇪🏳️‍🌈") -fmt.Println(n) -// 2 -``` - -### Calculating the Monospace String Width - -```go -width := uniseg.StringWidth("🇩🇪🏳️‍🌈!") -fmt.Println(width) -// 5 -``` - -### Using the [`Graphemes`](https://pkg.go.dev/github.com/rivo/uniseg#Graphemes) Class - -This is the most convenient method of iterating over grapheme clusters: - -```go -gr := uniseg.NewGraphemes("👍🏼!") -for gr.Next() { - fmt.Printf("%x ", gr.Runes()) -} -// [1f44d 1f3fc] [21] -``` - -### Using the [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step) or [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString) Function - -This avoids allocating a new `Graphemes` object but it requires the handling of states and boundaries: - -```go -str := "🇩🇪🏳️‍🌈" -state := -1 -var c string -for len(str) > 0 { - c, str, _, state = uniseg.StepString(str, state) - fmt.Printf("%x ", []rune(c)) -} -// [1f1e9 1f1ea] [1f3f3 fe0f 200d 1f308] -``` - -### Advanced Examples - -The [`Graphemes`](https://pkg.go.dev/github.com/rivo/uniseg#Graphemes) class offers the most convenient way to access all functionality of this package. But in some cases, it may be better to use the specialized functions directly. For example, if you're only interested in word segmentation, use [`FirstWord`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWord) or [`FirstWordInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstWordInString): - -```go -str := "Hello, world!" -state := -1 -var c string -for len(str) > 0 { - c, str, state = uniseg.FirstWordInString(str, state) - fmt.Printf("(%s)\n", c) -} -// (Hello) -// (,) -// ( ) -// (world) -// (!) -``` - -Similarly, use - -- [`FirstGraphemeCluster`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeCluster) or [`FirstGraphemeClusterInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeClusterInString) for grapheme cluster determination only, -- [`FirstSentence`](https://pkg.go.dev/github.com/rivo/uniseg#FirstSentence) or [`FirstSentenceInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstSentenceInString) for sentence segmentation only, and -- [`FirstLineSegment`](https://pkg.go.dev/github.com/rivo/uniseg#FirstLineSegment) or [`FirstLineSegmentInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstLineSegmentInString) for line breaking / word wrapping (although using [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step) or [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString) is preferred as it will observe grapheme cluster boundaries). - -If you're only interested in the width of characters, use [`FirstGraphemeCluster`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeCluster) or [`FirstGraphemeClusterInString`](https://pkg.go.dev/github.com/rivo/uniseg#FirstGraphemeClusterInString). It is much faster than using [`Step`](https://pkg.go.dev/github.com/rivo/uniseg#Step), [`StepString`](https://pkg.go.dev/github.com/rivo/uniseg#StepString), or the [`Graphemes`](https://pkg.go.dev/github.com/rivo/uniseg#Graphemes) class because it does not include the logic for word / sentence / line boundaries. - -Finally, if you need to reverse a string while preserving grapheme clusters, use [`ReverseString`](https://pkg.go.dev/github.com/rivo/uniseg#ReverseString): - -```go -fmt.Println(uniseg.ReverseString("🇩🇪🏳️‍🌈")) -// 🏳️‍🌈🇩🇪 -``` - -## Documentation - -Refer to https://pkg.go.dev/github.com/rivo/uniseg for the package's documentation. - -## Dependencies - -This package does not depend on any packages outside the standard library. - -## Sponsor this Project - -[Become a Sponsor on GitHub](https://github.com/sponsors/rivo?metadata_source=uniseg_readme) to support this project! - -## Your Feedback - -Add your issue here on GitHub, preferably before submitting any PR's. Feel free to get in touch if you have any questions. \ No newline at end of file diff --git a/vendor/github.com/rivo/uniseg/doc.go b/vendor/github.com/rivo/uniseg/doc.go deleted file mode 100644 index 11224ae..0000000 --- a/vendor/github.com/rivo/uniseg/doc.go +++ /dev/null @@ -1,108 +0,0 @@ -/* -Package uniseg implements Unicode Text Segmentation, Unicode Line Breaking, and -string width calculation for monospace fonts. Unicode Text Segmentation conforms -to Unicode Standard Annex #29 (https://unicode.org/reports/tr29/) and Unicode -Line Breaking conforms to Unicode Standard Annex #14 -(https://unicode.org/reports/tr14/). - -In short, using this package, you can split a string into grapheme clusters -(what people would usually refer to as a "character"), into words, and into -sentences. Or, in its simplest case, this package allows you to count the number -of characters in a string, especially when it contains complex characters such -as emojis, combining characters, or characters from Asian, Arabic, Hebrew, or -other languages. Additionally, you can use it to implement line breaking (or -"word wrapping"), that is, to determine where text can be broken over to the -next line when the width of the line is not big enough to fit the entire text. -Finally, you can use it to calculate the display width of a string for monospace -fonts. - -# Getting Started - -If you just want to count the number of characters in a string, you can use -[GraphemeClusterCount]. If you want to determine the display width of a string, -you can use [StringWidth]. If you want to iterate over a string, you can use -[Step], [StepString], or the [Graphemes] class (more convenient but less -performant). This will provide you with all information: grapheme clusters, -word boundaries, sentence boundaries, line breaks, and monospace character -widths. The specialized functions [FirstGraphemeCluster], -[FirstGraphemeClusterInString], [FirstWord], [FirstWordInString], -[FirstSentence], and [FirstSentenceInString] can be used if only one type of -information is needed. - -# Grapheme Clusters - -Consider the rainbow flag emoji: 🏳️‍🌈. On most modern systems, it appears as one -character. But its string representation actually has 14 bytes, so counting -bytes (or using len("🏳️‍🌈")) will not work as expected. Counting runes won't, -either: The flag has 4 Unicode code points, thus 4 runes. The stdlib function -utf8.RuneCountInString("🏳️‍🌈") and len([]rune("🏳️‍🌈")) will both return 4. - -The [GraphemeClusterCount] function will return 1 for the rainbow flag emoji. -The Graphemes class and a variety of functions in this package will allow you to -split strings into its grapheme clusters. - -# Word Boundaries - -Word boundaries are used in a number of different contexts. The most familiar -ones are selection (double-click mouse selection), cursor movement ("move to -next word" control-arrow keys), and the dialog option "Whole Word Search" for -search and replace. This package provides methods for determining word -boundaries. - -# Sentence Boundaries - -Sentence boundaries are often used for triple-click or some other method of -selecting or iterating through blocks of text that are larger than single words. -They are also used to determine whether words occur within the same sentence in -database queries. This package provides methods for determining sentence -boundaries. - -# Line Breaking - -Line breaking, also known as word wrapping, is the process of breaking a section -of text into lines such that it will fit in the available width of a page, -window or other display area. This package provides methods to determine the -positions in a string where a line must be broken, may be broken, or must not be -broken. - -# Monospace Width - -Monospace width, as referred to in this package, is the width of a string in a -monospace font. This is commonly used in terminal user interfaces or text -displays or editors that don't support proportional fonts. A width of 1 -corresponds to a single character cell. The C function [wcswidth()] and its -implementation in other programming languages is in widespread use for the same -purpose. However, there is no standard for the calculation of such widths, and -this package differs from wcswidth() in a number of ways, presumably to generate -more visually pleasing results. - -To start, we assume that every code point has a width of 1, with the following -exceptions: - - - Code points with grapheme cluster break properties Control, CR, LF, Extend, - and ZWJ have a width of 0. - - U+2E3A, Two-Em Dash, has a width of 3. - - U+2E3B, Three-Em Dash, has a width of 4. - - Characters with the East-Asian Width properties "Fullwidth" (F) and "Wide" - (W) have a width of 2. (Properties "Ambiguous" (A) and "Neutral" (N) both - have a width of 1.) - - Code points with grapheme cluster break property Regional Indicator have a - width of 2. - - Code points with grapheme cluster break property Extended Pictographic have - a width of 2, unless their Emoji Presentation flag is "No", in which case - the width is 1. - -For Hangul grapheme clusters composed of conjoining Jamo and for Regional -Indicators (flags), all code points except the first one have a width of 0. For -grapheme clusters starting with an Extended Pictographic, any additional code -point will force a total width of 2, except if the Variation Selector-15 -(U+FE0E) is included, in which case the total width is always 1. Grapheme -clusters ending with Variation Selector-16 (U+FE0F) have a width of 2. - -Note that whether these widths appear correct depends on your application's -render engine, to which extent it conforms to the Unicode Standard, and its -choice of font. - -[wcswidth()]: https://man7.org/linux/man-pages/man3/wcswidth.3.html -*/ -package uniseg diff --git a/vendor/github.com/rivo/uniseg/eastasianwidth.go b/vendor/github.com/rivo/uniseg/eastasianwidth.go deleted file mode 100644 index 5fc54d9..0000000 --- a/vendor/github.com/rivo/uniseg/eastasianwidth.go +++ /dev/null @@ -1,2588 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// eastAsianWidth are taken from -// https://www.unicode.org/Public/15.0.0/ucd/EastAsianWidth.txt -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var eastAsianWidth = [][3]int{ - {0x0000, 0x001F, prN}, // Cc [32] .. - {0x0020, 0x0020, prNa}, // Zs SPACE - {0x0021, 0x0023, prNa}, // Po [3] EXCLAMATION MARK..NUMBER SIGN - {0x0024, 0x0024, prNa}, // Sc DOLLAR SIGN - {0x0025, 0x0027, prNa}, // Po [3] PERCENT SIGN..APOSTROPHE - {0x0028, 0x0028, prNa}, // Ps LEFT PARENTHESIS - {0x0029, 0x0029, prNa}, // Pe RIGHT PARENTHESIS - {0x002A, 0x002A, prNa}, // Po ASTERISK - {0x002B, 0x002B, prNa}, // Sm PLUS SIGN - {0x002C, 0x002C, prNa}, // Po COMMA - {0x002D, 0x002D, prNa}, // Pd HYPHEN-MINUS - {0x002E, 0x002F, prNa}, // Po [2] FULL STOP..SOLIDUS - {0x0030, 0x0039, prNa}, // Nd [10] DIGIT ZERO..DIGIT NINE - {0x003A, 0x003B, prNa}, // Po [2] COLON..SEMICOLON - {0x003C, 0x003E, prNa}, // Sm [3] LESS-THAN SIGN..GREATER-THAN SIGN - {0x003F, 0x0040, prNa}, // Po [2] QUESTION MARK..COMMERCIAL AT - {0x0041, 0x005A, prNa}, // Lu [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z - {0x005B, 0x005B, prNa}, // Ps LEFT SQUARE BRACKET - {0x005C, 0x005C, prNa}, // Po REVERSE SOLIDUS - {0x005D, 0x005D, prNa}, // Pe RIGHT SQUARE BRACKET - {0x005E, 0x005E, prNa}, // Sk CIRCUMFLEX ACCENT - {0x005F, 0x005F, prNa}, // Pc LOW LINE - {0x0060, 0x0060, prNa}, // Sk GRAVE ACCENT - {0x0061, 0x007A, prNa}, // Ll [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z - {0x007B, 0x007B, prNa}, // Ps LEFT CURLY BRACKET - {0x007C, 0x007C, prNa}, // Sm VERTICAL LINE - {0x007D, 0x007D, prNa}, // Pe RIGHT CURLY BRACKET - {0x007E, 0x007E, prNa}, // Sm TILDE - {0x007F, 0x007F, prN}, // Cc - {0x0080, 0x009F, prN}, // Cc [32] .. - {0x00A0, 0x00A0, prN}, // Zs NO-BREAK SPACE - {0x00A1, 0x00A1, prA}, // Po INVERTED EXCLAMATION MARK - {0x00A2, 0x00A3, prNa}, // Sc [2] CENT SIGN..POUND SIGN - {0x00A4, 0x00A4, prA}, // Sc CURRENCY SIGN - {0x00A5, 0x00A5, prNa}, // Sc YEN SIGN - {0x00A6, 0x00A6, prNa}, // So BROKEN BAR - {0x00A7, 0x00A7, prA}, // Po SECTION SIGN - {0x00A8, 0x00A8, prA}, // Sk DIAERESIS - {0x00A9, 0x00A9, prN}, // So COPYRIGHT SIGN - {0x00AA, 0x00AA, prA}, // Lo FEMININE ORDINAL INDICATOR - {0x00AB, 0x00AB, prN}, // Pi LEFT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00AC, 0x00AC, prNa}, // Sm NOT SIGN - {0x00AD, 0x00AD, prA}, // Cf SOFT HYPHEN - {0x00AE, 0x00AE, prA}, // So REGISTERED SIGN - {0x00AF, 0x00AF, prNa}, // Sk MACRON - {0x00B0, 0x00B0, prA}, // So DEGREE SIGN - {0x00B1, 0x00B1, prA}, // Sm PLUS-MINUS SIGN - {0x00B2, 0x00B3, prA}, // No [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE - {0x00B4, 0x00B4, prA}, // Sk ACUTE ACCENT - {0x00B5, 0x00B5, prN}, // Ll MICRO SIGN - {0x00B6, 0x00B7, prA}, // Po [2] PILCROW SIGN..MIDDLE DOT - {0x00B8, 0x00B8, prA}, // Sk CEDILLA - {0x00B9, 0x00B9, prA}, // No SUPERSCRIPT ONE - {0x00BA, 0x00BA, prA}, // Lo MASCULINE ORDINAL INDICATOR - {0x00BB, 0x00BB, prN}, // Pf RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00BC, 0x00BE, prA}, // No [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS - {0x00BF, 0x00BF, prA}, // Po INVERTED QUESTION MARK - {0x00C0, 0x00C5, prN}, // Lu [6] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER A WITH RING ABOVE - {0x00C6, 0x00C6, prA}, // Lu LATIN CAPITAL LETTER AE - {0x00C7, 0x00CF, prN}, // Lu [9] LATIN CAPITAL LETTER C WITH CEDILLA..LATIN CAPITAL LETTER I WITH DIAERESIS - {0x00D0, 0x00D0, prA}, // Lu LATIN CAPITAL LETTER ETH - {0x00D1, 0x00D6, prN}, // Lu [6] LATIN CAPITAL LETTER N WITH TILDE..LATIN CAPITAL LETTER O WITH DIAERESIS - {0x00D7, 0x00D7, prA}, // Sm MULTIPLICATION SIGN - {0x00D8, 0x00D8, prA}, // Lu LATIN CAPITAL LETTER O WITH STROKE - {0x00D9, 0x00DD, prN}, // Lu [5] LATIN CAPITAL LETTER U WITH GRAVE..LATIN CAPITAL LETTER Y WITH ACUTE - {0x00DE, 0x00E1, prA}, // L& [4] LATIN CAPITAL LETTER THORN..LATIN SMALL LETTER A WITH ACUTE - {0x00E2, 0x00E5, prN}, // Ll [4] LATIN SMALL LETTER A WITH CIRCUMFLEX..LATIN SMALL LETTER A WITH RING ABOVE - {0x00E6, 0x00E6, prA}, // Ll LATIN SMALL LETTER AE - {0x00E7, 0x00E7, prN}, // Ll LATIN SMALL LETTER C WITH CEDILLA - {0x00E8, 0x00EA, prA}, // Ll [3] LATIN SMALL LETTER E WITH GRAVE..LATIN SMALL LETTER E WITH CIRCUMFLEX - {0x00EB, 0x00EB, prN}, // Ll LATIN SMALL LETTER E WITH DIAERESIS - {0x00EC, 0x00ED, prA}, // Ll [2] LATIN SMALL LETTER I WITH GRAVE..LATIN SMALL LETTER I WITH ACUTE - {0x00EE, 0x00EF, prN}, // Ll [2] LATIN SMALL LETTER I WITH CIRCUMFLEX..LATIN SMALL LETTER I WITH DIAERESIS - {0x00F0, 0x00F0, prA}, // Ll LATIN SMALL LETTER ETH - {0x00F1, 0x00F1, prN}, // Ll LATIN SMALL LETTER N WITH TILDE - {0x00F2, 0x00F3, prA}, // Ll [2] LATIN SMALL LETTER O WITH GRAVE..LATIN SMALL LETTER O WITH ACUTE - {0x00F4, 0x00F6, prN}, // Ll [3] LATIN SMALL LETTER O WITH CIRCUMFLEX..LATIN SMALL LETTER O WITH DIAERESIS - {0x00F7, 0x00F7, prA}, // Sm DIVISION SIGN - {0x00F8, 0x00FA, prA}, // Ll [3] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER U WITH ACUTE - {0x00FB, 0x00FB, prN}, // Ll LATIN SMALL LETTER U WITH CIRCUMFLEX - {0x00FC, 0x00FC, prA}, // Ll LATIN SMALL LETTER U WITH DIAERESIS - {0x00FD, 0x00FD, prN}, // Ll LATIN SMALL LETTER Y WITH ACUTE - {0x00FE, 0x00FE, prA}, // Ll LATIN SMALL LETTER THORN - {0x00FF, 0x00FF, prN}, // Ll LATIN SMALL LETTER Y WITH DIAERESIS - {0x0100, 0x0100, prN}, // Lu LATIN CAPITAL LETTER A WITH MACRON - {0x0101, 0x0101, prA}, // Ll LATIN SMALL LETTER A WITH MACRON - {0x0102, 0x0110, prN}, // L& [15] LATIN CAPITAL LETTER A WITH BREVE..LATIN CAPITAL LETTER D WITH STROKE - {0x0111, 0x0111, prA}, // Ll LATIN SMALL LETTER D WITH STROKE - {0x0112, 0x0112, prN}, // Lu LATIN CAPITAL LETTER E WITH MACRON - {0x0113, 0x0113, prA}, // Ll LATIN SMALL LETTER E WITH MACRON - {0x0114, 0x011A, prN}, // L& [7] LATIN CAPITAL LETTER E WITH BREVE..LATIN CAPITAL LETTER E WITH CARON - {0x011B, 0x011B, prA}, // Ll LATIN SMALL LETTER E WITH CARON - {0x011C, 0x0125, prN}, // L& [10] LATIN CAPITAL LETTER G WITH CIRCUMFLEX..LATIN SMALL LETTER H WITH CIRCUMFLEX - {0x0126, 0x0127, prA}, // L& [2] LATIN CAPITAL LETTER H WITH STROKE..LATIN SMALL LETTER H WITH STROKE - {0x0128, 0x012A, prN}, // L& [3] LATIN CAPITAL LETTER I WITH TILDE..LATIN CAPITAL LETTER I WITH MACRON - {0x012B, 0x012B, prA}, // Ll LATIN SMALL LETTER I WITH MACRON - {0x012C, 0x0130, prN}, // L& [5] LATIN CAPITAL LETTER I WITH BREVE..LATIN CAPITAL LETTER I WITH DOT ABOVE - {0x0131, 0x0133, prA}, // L& [3] LATIN SMALL LETTER DOTLESS I..LATIN SMALL LIGATURE IJ - {0x0134, 0x0137, prN}, // L& [4] LATIN CAPITAL LETTER J WITH CIRCUMFLEX..LATIN SMALL LETTER K WITH CEDILLA - {0x0138, 0x0138, prA}, // Ll LATIN SMALL LETTER KRA - {0x0139, 0x013E, prN}, // L& [6] LATIN CAPITAL LETTER L WITH ACUTE..LATIN SMALL LETTER L WITH CARON - {0x013F, 0x0142, prA}, // L& [4] LATIN CAPITAL LETTER L WITH MIDDLE DOT..LATIN SMALL LETTER L WITH STROKE - {0x0143, 0x0143, prN}, // Lu LATIN CAPITAL LETTER N WITH ACUTE - {0x0144, 0x0144, prA}, // Ll LATIN SMALL LETTER N WITH ACUTE - {0x0145, 0x0147, prN}, // L& [3] LATIN CAPITAL LETTER N WITH CEDILLA..LATIN CAPITAL LETTER N WITH CARON - {0x0148, 0x014B, prA}, // L& [4] LATIN SMALL LETTER N WITH CARON..LATIN SMALL LETTER ENG - {0x014C, 0x014C, prN}, // Lu LATIN CAPITAL LETTER O WITH MACRON - {0x014D, 0x014D, prA}, // Ll LATIN SMALL LETTER O WITH MACRON - {0x014E, 0x0151, prN}, // L& [4] LATIN CAPITAL LETTER O WITH BREVE..LATIN SMALL LETTER O WITH DOUBLE ACUTE - {0x0152, 0x0153, prA}, // L& [2] LATIN CAPITAL LIGATURE OE..LATIN SMALL LIGATURE OE - {0x0154, 0x0165, prN}, // L& [18] LATIN CAPITAL LETTER R WITH ACUTE..LATIN SMALL LETTER T WITH CARON - {0x0166, 0x0167, prA}, // L& [2] LATIN CAPITAL LETTER T WITH STROKE..LATIN SMALL LETTER T WITH STROKE - {0x0168, 0x016A, prN}, // L& [3] LATIN CAPITAL LETTER U WITH TILDE..LATIN CAPITAL LETTER U WITH MACRON - {0x016B, 0x016B, prA}, // Ll LATIN SMALL LETTER U WITH MACRON - {0x016C, 0x017F, prN}, // L& [20] LATIN CAPITAL LETTER U WITH BREVE..LATIN SMALL LETTER LONG S - {0x0180, 0x01BA, prN}, // L& [59] LATIN SMALL LETTER B WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL - {0x01BB, 0x01BB, prN}, // Lo LATIN LETTER TWO WITH STROKE - {0x01BC, 0x01BF, prN}, // L& [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN - {0x01C0, 0x01C3, prN}, // Lo [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK - {0x01C4, 0x01CD, prN}, // L& [10] LATIN CAPITAL LETTER DZ WITH CARON..LATIN CAPITAL LETTER A WITH CARON - {0x01CE, 0x01CE, prA}, // Ll LATIN SMALL LETTER A WITH CARON - {0x01CF, 0x01CF, prN}, // Lu LATIN CAPITAL LETTER I WITH CARON - {0x01D0, 0x01D0, prA}, // Ll LATIN SMALL LETTER I WITH CARON - {0x01D1, 0x01D1, prN}, // Lu LATIN CAPITAL LETTER O WITH CARON - {0x01D2, 0x01D2, prA}, // Ll LATIN SMALL LETTER O WITH CARON - {0x01D3, 0x01D3, prN}, // Lu LATIN CAPITAL LETTER U WITH CARON - {0x01D4, 0x01D4, prA}, // Ll LATIN SMALL LETTER U WITH CARON - {0x01D5, 0x01D5, prN}, // Lu LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON - {0x01D6, 0x01D6, prA}, // Ll LATIN SMALL LETTER U WITH DIAERESIS AND MACRON - {0x01D7, 0x01D7, prN}, // Lu LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE - {0x01D8, 0x01D8, prA}, // Ll LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE - {0x01D9, 0x01D9, prN}, // Lu LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON - {0x01DA, 0x01DA, prA}, // Ll LATIN SMALL LETTER U WITH DIAERESIS AND CARON - {0x01DB, 0x01DB, prN}, // Lu LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE - {0x01DC, 0x01DC, prA}, // Ll LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE - {0x01DD, 0x024F, prN}, // L& [115] LATIN SMALL LETTER TURNED E..LATIN SMALL LETTER Y WITH STROKE - {0x0250, 0x0250, prN}, // Ll LATIN SMALL LETTER TURNED A - {0x0251, 0x0251, prA}, // Ll LATIN SMALL LETTER ALPHA - {0x0252, 0x0260, prN}, // Ll [15] LATIN SMALL LETTER TURNED ALPHA..LATIN SMALL LETTER G WITH HOOK - {0x0261, 0x0261, prA}, // Ll LATIN SMALL LETTER SCRIPT G - {0x0262, 0x0293, prN}, // Ll [50] LATIN LETTER SMALL CAPITAL G..LATIN SMALL LETTER EZH WITH CURL - {0x0294, 0x0294, prN}, // Lo LATIN LETTER GLOTTAL STOP - {0x0295, 0x02AF, prN}, // Ll [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL - {0x02B0, 0x02C1, prN}, // Lm [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP - {0x02C2, 0x02C3, prN}, // Sk [2] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER RIGHT ARROWHEAD - {0x02C4, 0x02C4, prA}, // Sk MODIFIER LETTER UP ARROWHEAD - {0x02C5, 0x02C5, prN}, // Sk MODIFIER LETTER DOWN ARROWHEAD - {0x02C6, 0x02C6, prN}, // Lm MODIFIER LETTER CIRCUMFLEX ACCENT - {0x02C7, 0x02C7, prA}, // Lm CARON - {0x02C8, 0x02C8, prN}, // Lm MODIFIER LETTER VERTICAL LINE - {0x02C9, 0x02CB, prA}, // Lm [3] MODIFIER LETTER MACRON..MODIFIER LETTER GRAVE ACCENT - {0x02CC, 0x02CC, prN}, // Lm MODIFIER LETTER LOW VERTICAL LINE - {0x02CD, 0x02CD, prA}, // Lm MODIFIER LETTER LOW MACRON - {0x02CE, 0x02CF, prN}, // Lm [2] MODIFIER LETTER LOW GRAVE ACCENT..MODIFIER LETTER LOW ACUTE ACCENT - {0x02D0, 0x02D0, prA}, // Lm MODIFIER LETTER TRIANGULAR COLON - {0x02D1, 0x02D1, prN}, // Lm MODIFIER LETTER HALF TRIANGULAR COLON - {0x02D2, 0x02D7, prN}, // Sk [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN - {0x02D8, 0x02DB, prA}, // Sk [4] BREVE..OGONEK - {0x02DC, 0x02DC, prN}, // Sk SMALL TILDE - {0x02DD, 0x02DD, prA}, // Sk DOUBLE ACUTE ACCENT - {0x02DE, 0x02DE, prN}, // Sk MODIFIER LETTER RHOTIC HOOK - {0x02DF, 0x02DF, prA}, // Sk MODIFIER LETTER CROSS ACCENT - {0x02E0, 0x02E4, prN}, // Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP - {0x02E5, 0x02EB, prN}, // Sk [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK - {0x02EC, 0x02EC, prN}, // Lm MODIFIER LETTER VOICING - {0x02ED, 0x02ED, prN}, // Sk MODIFIER LETTER UNASPIRATED - {0x02EE, 0x02EE, prN}, // Lm MODIFIER LETTER DOUBLE APOSTROPHE - {0x02EF, 0x02FF, prN}, // Sk [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW - {0x0300, 0x036F, prA}, // Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X - {0x0370, 0x0373, prN}, // L& [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI - {0x0374, 0x0374, prN}, // Lm GREEK NUMERAL SIGN - {0x0375, 0x0375, prN}, // Sk GREEK LOWER NUMERAL SIGN - {0x0376, 0x0377, prN}, // L& [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA - {0x037A, 0x037A, prN}, // Lm GREEK YPOGEGRAMMENI - {0x037B, 0x037D, prN}, // Ll [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x037E, 0x037E, prN}, // Po GREEK QUESTION MARK - {0x037F, 0x037F, prN}, // Lu GREEK CAPITAL LETTER YOT - {0x0384, 0x0385, prN}, // Sk [2] GREEK TONOS..GREEK DIALYTIKA TONOS - {0x0386, 0x0386, prN}, // Lu GREEK CAPITAL LETTER ALPHA WITH TONOS - {0x0387, 0x0387, prN}, // Po GREEK ANO TELEIA - {0x0388, 0x038A, prN}, // Lu [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS - {0x038C, 0x038C, prN}, // Lu GREEK CAPITAL LETTER OMICRON WITH TONOS - {0x038E, 0x0390, prN}, // L& [3] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS - {0x0391, 0x03A1, prA}, // Lu [17] GREEK CAPITAL LETTER ALPHA..GREEK CAPITAL LETTER RHO - {0x03A3, 0x03A9, prA}, // Lu [7] GREEK CAPITAL LETTER SIGMA..GREEK CAPITAL LETTER OMEGA - {0x03AA, 0x03B0, prN}, // L& [7] GREEK CAPITAL LETTER IOTA WITH DIALYTIKA..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS - {0x03B1, 0x03C1, prA}, // Ll [17] GREEK SMALL LETTER ALPHA..GREEK SMALL LETTER RHO - {0x03C2, 0x03C2, prN}, // Ll GREEK SMALL LETTER FINAL SIGMA - {0x03C3, 0x03C9, prA}, // Ll [7] GREEK SMALL LETTER SIGMA..GREEK SMALL LETTER OMEGA - {0x03CA, 0x03F5, prN}, // L& [44] GREEK SMALL LETTER IOTA WITH DIALYTIKA..GREEK LUNATE EPSILON SYMBOL - {0x03F6, 0x03F6, prN}, // Sm GREEK REVERSED LUNATE EPSILON SYMBOL - {0x03F7, 0x03FF, prN}, // L& [9] GREEK CAPITAL LETTER SHO..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x0400, 0x0400, prN}, // Lu CYRILLIC CAPITAL LETTER IE WITH GRAVE - {0x0401, 0x0401, prA}, // Lu CYRILLIC CAPITAL LETTER IO - {0x0402, 0x040F, prN}, // Lu [14] CYRILLIC CAPITAL LETTER DJE..CYRILLIC CAPITAL LETTER DZHE - {0x0410, 0x044F, prA}, // L& [64] CYRILLIC CAPITAL LETTER A..CYRILLIC SMALL LETTER YA - {0x0450, 0x0450, prN}, // Ll CYRILLIC SMALL LETTER IE WITH GRAVE - {0x0451, 0x0451, prA}, // Ll CYRILLIC SMALL LETTER IO - {0x0452, 0x0481, prN}, // L& [48] CYRILLIC SMALL LETTER DJE..CYRILLIC SMALL LETTER KOPPA - {0x0482, 0x0482, prN}, // So CYRILLIC THOUSANDS SIGN - {0x0483, 0x0487, prN}, // Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE - {0x0488, 0x0489, prN}, // Me [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN - {0x048A, 0x04FF, prN}, // L& [118] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER HA WITH STROKE - {0x0500, 0x052F, prN}, // L& [48] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER EL WITH DESCENDER - {0x0531, 0x0556, prN}, // Lu [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH - {0x0559, 0x0559, prN}, // Lm ARMENIAN MODIFIER LETTER LEFT HALF RING - {0x055A, 0x055F, prN}, // Po [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK - {0x0560, 0x0588, prN}, // Ll [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE - {0x0589, 0x0589, prN}, // Po ARMENIAN FULL STOP - {0x058A, 0x058A, prN}, // Pd ARMENIAN HYPHEN - {0x058D, 0x058E, prN}, // So [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN - {0x058F, 0x058F, prN}, // Sc ARMENIAN DRAM SIGN - {0x0591, 0x05BD, prN}, // Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG - {0x05BE, 0x05BE, prN}, // Pd HEBREW PUNCTUATION MAQAF - {0x05BF, 0x05BF, prN}, // Mn HEBREW POINT RAFE - {0x05C0, 0x05C0, prN}, // Po HEBREW PUNCTUATION PASEQ - {0x05C1, 0x05C2, prN}, // Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT - {0x05C3, 0x05C3, prN}, // Po HEBREW PUNCTUATION SOF PASUQ - {0x05C4, 0x05C5, prN}, // Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT - {0x05C6, 0x05C6, prN}, // Po HEBREW PUNCTUATION NUN HAFUKHA - {0x05C7, 0x05C7, prN}, // Mn HEBREW POINT QAMATS QATAN - {0x05D0, 0x05EA, prN}, // Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV - {0x05EF, 0x05F2, prN}, // Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD - {0x05F3, 0x05F4, prN}, // Po [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM - {0x0600, 0x0605, prN}, // Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE - {0x0606, 0x0608, prN}, // Sm [3] ARABIC-INDIC CUBE ROOT..ARABIC RAY - {0x0609, 0x060A, prN}, // Po [2] ARABIC-INDIC PER MILLE SIGN..ARABIC-INDIC PER TEN THOUSAND SIGN - {0x060B, 0x060B, prN}, // Sc AFGHANI SIGN - {0x060C, 0x060D, prN}, // Po [2] ARABIC COMMA..ARABIC DATE SEPARATOR - {0x060E, 0x060F, prN}, // So [2] ARABIC POETIC VERSE SIGN..ARABIC SIGN MISRA - {0x0610, 0x061A, prN}, // Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA - {0x061B, 0x061B, prN}, // Po ARABIC SEMICOLON - {0x061C, 0x061C, prN}, // Cf ARABIC LETTER MARK - {0x061D, 0x061F, prN}, // Po [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK - {0x0620, 0x063F, prN}, // Lo [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE - {0x0640, 0x0640, prN}, // Lm ARABIC TATWEEL - {0x0641, 0x064A, prN}, // Lo [10] ARABIC LETTER FEH..ARABIC LETTER YEH - {0x064B, 0x065F, prN}, // Mn [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW - {0x0660, 0x0669, prN}, // Nd [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE - {0x066A, 0x066D, prN}, // Po [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR - {0x066E, 0x066F, prN}, // Lo [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF - {0x0670, 0x0670, prN}, // Mn ARABIC LETTER SUPERSCRIPT ALEF - {0x0671, 0x06D3, prN}, // Lo [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE - {0x06D4, 0x06D4, prN}, // Po ARABIC FULL STOP - {0x06D5, 0x06D5, prN}, // Lo ARABIC LETTER AE - {0x06D6, 0x06DC, prN}, // Mn [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN - {0x06DD, 0x06DD, prN}, // Cf ARABIC END OF AYAH - {0x06DE, 0x06DE, prN}, // So ARABIC START OF RUB EL HIZB - {0x06DF, 0x06E4, prN}, // Mn [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA - {0x06E5, 0x06E6, prN}, // Lm [2] ARABIC SMALL WAW..ARABIC SMALL YEH - {0x06E7, 0x06E8, prN}, // Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON - {0x06E9, 0x06E9, prN}, // So ARABIC PLACE OF SAJDAH - {0x06EA, 0x06ED, prN}, // Mn [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM - {0x06EE, 0x06EF, prN}, // Lo [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V - {0x06F0, 0x06F9, prN}, // Nd [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE - {0x06FA, 0x06FC, prN}, // Lo [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW - {0x06FD, 0x06FE, prN}, // So [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN - {0x06FF, 0x06FF, prN}, // Lo ARABIC LETTER HEH WITH INVERTED V - {0x0700, 0x070D, prN}, // Po [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS - {0x070F, 0x070F, prN}, // Cf SYRIAC ABBREVIATION MARK - {0x0710, 0x0710, prN}, // Lo SYRIAC LETTER ALAPH - {0x0711, 0x0711, prN}, // Mn SYRIAC LETTER SUPERSCRIPT ALAPH - {0x0712, 0x072F, prN}, // Lo [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH - {0x0730, 0x074A, prN}, // Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH - {0x074D, 0x074F, prN}, // Lo [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE - {0x0750, 0x077F, prN}, // Lo [48] ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS ABOVE - {0x0780, 0x07A5, prN}, // Lo [38] THAANA LETTER HAA..THAANA LETTER WAAVU - {0x07A6, 0x07B0, prN}, // Mn [11] THAANA ABAFILI..THAANA SUKUN - {0x07B1, 0x07B1, prN}, // Lo THAANA LETTER NAA - {0x07C0, 0x07C9, prN}, // Nd [10] NKO DIGIT ZERO..NKO DIGIT NINE - {0x07CA, 0x07EA, prN}, // Lo [33] NKO LETTER A..NKO LETTER JONA RA - {0x07EB, 0x07F3, prN}, // Mn [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE - {0x07F4, 0x07F5, prN}, // Lm [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE - {0x07F6, 0x07F6, prN}, // So NKO SYMBOL OO DENNEN - {0x07F7, 0x07F9, prN}, // Po [3] NKO SYMBOL GBAKURUNEN..NKO EXCLAMATION MARK - {0x07FA, 0x07FA, prN}, // Lm NKO LAJANYALAN - {0x07FD, 0x07FD, prN}, // Mn NKO DANTAYALAN - {0x07FE, 0x07FF, prN}, // Sc [2] NKO DOROME SIGN..NKO TAMAN SIGN - {0x0800, 0x0815, prN}, // Lo [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF - {0x0816, 0x0819, prN}, // Mn [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH - {0x081A, 0x081A, prN}, // Lm SAMARITAN MODIFIER LETTER EPENTHETIC YUT - {0x081B, 0x0823, prN}, // Mn [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A - {0x0824, 0x0824, prN}, // Lm SAMARITAN MODIFIER LETTER SHORT A - {0x0825, 0x0827, prN}, // Mn [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U - {0x0828, 0x0828, prN}, // Lm SAMARITAN MODIFIER LETTER I - {0x0829, 0x082D, prN}, // Mn [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA - {0x0830, 0x083E, prN}, // Po [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU - {0x0840, 0x0858, prN}, // Lo [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN - {0x0859, 0x085B, prN}, // Mn [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK - {0x085E, 0x085E, prN}, // Po MANDAIC PUNCTUATION - {0x0860, 0x086A, prN}, // Lo [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA - {0x0870, 0x0887, prN}, // Lo [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT - {0x0888, 0x0888, prN}, // Sk ARABIC RAISED ROUND DOT - {0x0889, 0x088E, prN}, // Lo [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL - {0x0890, 0x0891, prN}, // Cf [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE - {0x0898, 0x089F, prN}, // Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA - {0x08A0, 0x08C8, prN}, // Lo [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF - {0x08C9, 0x08C9, prN}, // Lm ARABIC SMALL FARSI YEH - {0x08CA, 0x08E1, prN}, // Mn [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA - {0x08E2, 0x08E2, prN}, // Cf ARABIC DISPUTED END OF AYAH - {0x08E3, 0x08FF, prN}, // Mn [29] ARABIC TURNED DAMMA BELOW..ARABIC MARK SIDEWAYS NOON GHUNNA - {0x0900, 0x0902, prN}, // Mn [3] DEVANAGARI SIGN INVERTED CANDRABINDU..DEVANAGARI SIGN ANUSVARA - {0x0903, 0x0903, prN}, // Mc DEVANAGARI SIGN VISARGA - {0x0904, 0x0939, prN}, // Lo [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA - {0x093A, 0x093A, prN}, // Mn DEVANAGARI VOWEL SIGN OE - {0x093B, 0x093B, prN}, // Mc DEVANAGARI VOWEL SIGN OOE - {0x093C, 0x093C, prN}, // Mn DEVANAGARI SIGN NUKTA - {0x093D, 0x093D, prN}, // Lo DEVANAGARI SIGN AVAGRAHA - {0x093E, 0x0940, prN}, // Mc [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II - {0x0941, 0x0948, prN}, // Mn [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI - {0x0949, 0x094C, prN}, // Mc [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU - {0x094D, 0x094D, prN}, // Mn DEVANAGARI SIGN VIRAMA - {0x094E, 0x094F, prN}, // Mc [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW - {0x0950, 0x0950, prN}, // Lo DEVANAGARI OM - {0x0951, 0x0957, prN}, // Mn [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE - {0x0958, 0x0961, prN}, // Lo [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL - {0x0962, 0x0963, prN}, // Mn [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL - {0x0964, 0x0965, prN}, // Po [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA - {0x0966, 0x096F, prN}, // Nd [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE - {0x0970, 0x0970, prN}, // Po DEVANAGARI ABBREVIATION SIGN - {0x0971, 0x0971, prN}, // Lm DEVANAGARI SIGN HIGH SPACING DOT - {0x0972, 0x097F, prN}, // Lo [14] DEVANAGARI LETTER CANDRA A..DEVANAGARI LETTER BBA - {0x0980, 0x0980, prN}, // Lo BENGALI ANJI - {0x0981, 0x0981, prN}, // Mn BENGALI SIGN CANDRABINDU - {0x0982, 0x0983, prN}, // Mc [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA - {0x0985, 0x098C, prN}, // Lo [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L - {0x098F, 0x0990, prN}, // Lo [2] BENGALI LETTER E..BENGALI LETTER AI - {0x0993, 0x09A8, prN}, // Lo [22] BENGALI LETTER O..BENGALI LETTER NA - {0x09AA, 0x09B0, prN}, // Lo [7] BENGALI LETTER PA..BENGALI LETTER RA - {0x09B2, 0x09B2, prN}, // Lo BENGALI LETTER LA - {0x09B6, 0x09B9, prN}, // Lo [4] BENGALI LETTER SHA..BENGALI LETTER HA - {0x09BC, 0x09BC, prN}, // Mn BENGALI SIGN NUKTA - {0x09BD, 0x09BD, prN}, // Lo BENGALI SIGN AVAGRAHA - {0x09BE, 0x09C0, prN}, // Mc [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II - {0x09C1, 0x09C4, prN}, // Mn [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR - {0x09C7, 0x09C8, prN}, // Mc [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI - {0x09CB, 0x09CC, prN}, // Mc [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU - {0x09CD, 0x09CD, prN}, // Mn BENGALI SIGN VIRAMA - {0x09CE, 0x09CE, prN}, // Lo BENGALI LETTER KHANDA TA - {0x09D7, 0x09D7, prN}, // Mc BENGALI AU LENGTH MARK - {0x09DC, 0x09DD, prN}, // Lo [2] BENGALI LETTER RRA..BENGALI LETTER RHA - {0x09DF, 0x09E1, prN}, // Lo [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL - {0x09E2, 0x09E3, prN}, // Mn [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL - {0x09E6, 0x09EF, prN}, // Nd [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE - {0x09F0, 0x09F1, prN}, // Lo [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL - {0x09F2, 0x09F3, prN}, // Sc [2] BENGALI RUPEE MARK..BENGALI RUPEE SIGN - {0x09F4, 0x09F9, prN}, // No [6] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY DENOMINATOR SIXTEEN - {0x09FA, 0x09FA, prN}, // So BENGALI ISSHAR - {0x09FB, 0x09FB, prN}, // Sc BENGALI GANDA MARK - {0x09FC, 0x09FC, prN}, // Lo BENGALI LETTER VEDIC ANUSVARA - {0x09FD, 0x09FD, prN}, // Po BENGALI ABBREVIATION SIGN - {0x09FE, 0x09FE, prN}, // Mn BENGALI SANDHI MARK - {0x0A01, 0x0A02, prN}, // Mn [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI - {0x0A03, 0x0A03, prN}, // Mc GURMUKHI SIGN VISARGA - {0x0A05, 0x0A0A, prN}, // Lo [6] GURMUKHI LETTER A..GURMUKHI LETTER UU - {0x0A0F, 0x0A10, prN}, // Lo [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI - {0x0A13, 0x0A28, prN}, // Lo [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA - {0x0A2A, 0x0A30, prN}, // Lo [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA - {0x0A32, 0x0A33, prN}, // Lo [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA - {0x0A35, 0x0A36, prN}, // Lo [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA - {0x0A38, 0x0A39, prN}, // Lo [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA - {0x0A3C, 0x0A3C, prN}, // Mn GURMUKHI SIGN NUKTA - {0x0A3E, 0x0A40, prN}, // Mc [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II - {0x0A41, 0x0A42, prN}, // Mn [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU - {0x0A47, 0x0A48, prN}, // Mn [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI - {0x0A4B, 0x0A4D, prN}, // Mn [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA - {0x0A51, 0x0A51, prN}, // Mn GURMUKHI SIGN UDAAT - {0x0A59, 0x0A5C, prN}, // Lo [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA - {0x0A5E, 0x0A5E, prN}, // Lo GURMUKHI LETTER FA - {0x0A66, 0x0A6F, prN}, // Nd [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE - {0x0A70, 0x0A71, prN}, // Mn [2] GURMUKHI TIPPI..GURMUKHI ADDAK - {0x0A72, 0x0A74, prN}, // Lo [3] GURMUKHI IRI..GURMUKHI EK ONKAR - {0x0A75, 0x0A75, prN}, // Mn GURMUKHI SIGN YAKASH - {0x0A76, 0x0A76, prN}, // Po GURMUKHI ABBREVIATION SIGN - {0x0A81, 0x0A82, prN}, // Mn [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA - {0x0A83, 0x0A83, prN}, // Mc GUJARATI SIGN VISARGA - {0x0A85, 0x0A8D, prN}, // Lo [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E - {0x0A8F, 0x0A91, prN}, // Lo [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O - {0x0A93, 0x0AA8, prN}, // Lo [22] GUJARATI LETTER O..GUJARATI LETTER NA - {0x0AAA, 0x0AB0, prN}, // Lo [7] GUJARATI LETTER PA..GUJARATI LETTER RA - {0x0AB2, 0x0AB3, prN}, // Lo [2] GUJARATI LETTER LA..GUJARATI LETTER LLA - {0x0AB5, 0x0AB9, prN}, // Lo [5] GUJARATI LETTER VA..GUJARATI LETTER HA - {0x0ABC, 0x0ABC, prN}, // Mn GUJARATI SIGN NUKTA - {0x0ABD, 0x0ABD, prN}, // Lo GUJARATI SIGN AVAGRAHA - {0x0ABE, 0x0AC0, prN}, // Mc [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II - {0x0AC1, 0x0AC5, prN}, // Mn [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E - {0x0AC7, 0x0AC8, prN}, // Mn [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI - {0x0AC9, 0x0AC9, prN}, // Mc GUJARATI VOWEL SIGN CANDRA O - {0x0ACB, 0x0ACC, prN}, // Mc [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU - {0x0ACD, 0x0ACD, prN}, // Mn GUJARATI SIGN VIRAMA - {0x0AD0, 0x0AD0, prN}, // Lo GUJARATI OM - {0x0AE0, 0x0AE1, prN}, // Lo [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL - {0x0AE2, 0x0AE3, prN}, // Mn [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL - {0x0AE6, 0x0AEF, prN}, // Nd [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE - {0x0AF0, 0x0AF0, prN}, // Po GUJARATI ABBREVIATION SIGN - {0x0AF1, 0x0AF1, prN}, // Sc GUJARATI RUPEE SIGN - {0x0AF9, 0x0AF9, prN}, // Lo GUJARATI LETTER ZHA - {0x0AFA, 0x0AFF, prN}, // Mn [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE - {0x0B01, 0x0B01, prN}, // Mn ORIYA SIGN CANDRABINDU - {0x0B02, 0x0B03, prN}, // Mc [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA - {0x0B05, 0x0B0C, prN}, // Lo [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L - {0x0B0F, 0x0B10, prN}, // Lo [2] ORIYA LETTER E..ORIYA LETTER AI - {0x0B13, 0x0B28, prN}, // Lo [22] ORIYA LETTER O..ORIYA LETTER NA - {0x0B2A, 0x0B30, prN}, // Lo [7] ORIYA LETTER PA..ORIYA LETTER RA - {0x0B32, 0x0B33, prN}, // Lo [2] ORIYA LETTER LA..ORIYA LETTER LLA - {0x0B35, 0x0B39, prN}, // Lo [5] ORIYA LETTER VA..ORIYA LETTER HA - {0x0B3C, 0x0B3C, prN}, // Mn ORIYA SIGN NUKTA - {0x0B3D, 0x0B3D, prN}, // Lo ORIYA SIGN AVAGRAHA - {0x0B3E, 0x0B3E, prN}, // Mc ORIYA VOWEL SIGN AA - {0x0B3F, 0x0B3F, prN}, // Mn ORIYA VOWEL SIGN I - {0x0B40, 0x0B40, prN}, // Mc ORIYA VOWEL SIGN II - {0x0B41, 0x0B44, prN}, // Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR - {0x0B47, 0x0B48, prN}, // Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI - {0x0B4B, 0x0B4C, prN}, // Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU - {0x0B4D, 0x0B4D, prN}, // Mn ORIYA SIGN VIRAMA - {0x0B55, 0x0B56, prN}, // Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK - {0x0B57, 0x0B57, prN}, // Mc ORIYA AU LENGTH MARK - {0x0B5C, 0x0B5D, prN}, // Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA - {0x0B5F, 0x0B61, prN}, // Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL - {0x0B62, 0x0B63, prN}, // Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL - {0x0B66, 0x0B6F, prN}, // Nd [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE - {0x0B70, 0x0B70, prN}, // So ORIYA ISSHAR - {0x0B71, 0x0B71, prN}, // Lo ORIYA LETTER WA - {0x0B72, 0x0B77, prN}, // No [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS - {0x0B82, 0x0B82, prN}, // Mn TAMIL SIGN ANUSVARA - {0x0B83, 0x0B83, prN}, // Lo TAMIL SIGN VISARGA - {0x0B85, 0x0B8A, prN}, // Lo [6] TAMIL LETTER A..TAMIL LETTER UU - {0x0B8E, 0x0B90, prN}, // Lo [3] TAMIL LETTER E..TAMIL LETTER AI - {0x0B92, 0x0B95, prN}, // Lo [4] TAMIL LETTER O..TAMIL LETTER KA - {0x0B99, 0x0B9A, prN}, // Lo [2] TAMIL LETTER NGA..TAMIL LETTER CA - {0x0B9C, 0x0B9C, prN}, // Lo TAMIL LETTER JA - {0x0B9E, 0x0B9F, prN}, // Lo [2] TAMIL LETTER NYA..TAMIL LETTER TTA - {0x0BA3, 0x0BA4, prN}, // Lo [2] TAMIL LETTER NNA..TAMIL LETTER TA - {0x0BA8, 0x0BAA, prN}, // Lo [3] TAMIL LETTER NA..TAMIL LETTER PA - {0x0BAE, 0x0BB9, prN}, // Lo [12] TAMIL LETTER MA..TAMIL LETTER HA - {0x0BBE, 0x0BBF, prN}, // Mc [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I - {0x0BC0, 0x0BC0, prN}, // Mn TAMIL VOWEL SIGN II - {0x0BC1, 0x0BC2, prN}, // Mc [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU - {0x0BC6, 0x0BC8, prN}, // Mc [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI - {0x0BCA, 0x0BCC, prN}, // Mc [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU - {0x0BCD, 0x0BCD, prN}, // Mn TAMIL SIGN VIRAMA - {0x0BD0, 0x0BD0, prN}, // Lo TAMIL OM - {0x0BD7, 0x0BD7, prN}, // Mc TAMIL AU LENGTH MARK - {0x0BE6, 0x0BEF, prN}, // Nd [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE - {0x0BF0, 0x0BF2, prN}, // No [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND - {0x0BF3, 0x0BF8, prN}, // So [6] TAMIL DAY SIGN..TAMIL AS ABOVE SIGN - {0x0BF9, 0x0BF9, prN}, // Sc TAMIL RUPEE SIGN - {0x0BFA, 0x0BFA, prN}, // So TAMIL NUMBER SIGN - {0x0C00, 0x0C00, prN}, // Mn TELUGU SIGN COMBINING CANDRABINDU ABOVE - {0x0C01, 0x0C03, prN}, // Mc [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA - {0x0C04, 0x0C04, prN}, // Mn TELUGU SIGN COMBINING ANUSVARA ABOVE - {0x0C05, 0x0C0C, prN}, // Lo [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L - {0x0C0E, 0x0C10, prN}, // Lo [3] TELUGU LETTER E..TELUGU LETTER AI - {0x0C12, 0x0C28, prN}, // Lo [23] TELUGU LETTER O..TELUGU LETTER NA - {0x0C2A, 0x0C39, prN}, // Lo [16] TELUGU LETTER PA..TELUGU LETTER HA - {0x0C3C, 0x0C3C, prN}, // Mn TELUGU SIGN NUKTA - {0x0C3D, 0x0C3D, prN}, // Lo TELUGU SIGN AVAGRAHA - {0x0C3E, 0x0C40, prN}, // Mn [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II - {0x0C41, 0x0C44, prN}, // Mc [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR - {0x0C46, 0x0C48, prN}, // Mn [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI - {0x0C4A, 0x0C4D, prN}, // Mn [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA - {0x0C55, 0x0C56, prN}, // Mn [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK - {0x0C58, 0x0C5A, prN}, // Lo [3] TELUGU LETTER TSA..TELUGU LETTER RRRA - {0x0C5D, 0x0C5D, prN}, // Lo TELUGU LETTER NAKAARA POLLU - {0x0C60, 0x0C61, prN}, // Lo [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL - {0x0C62, 0x0C63, prN}, // Mn [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL - {0x0C66, 0x0C6F, prN}, // Nd [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE - {0x0C77, 0x0C77, prN}, // Po TELUGU SIGN SIDDHAM - {0x0C78, 0x0C7E, prN}, // No [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR - {0x0C7F, 0x0C7F, prN}, // So TELUGU SIGN TUUMU - {0x0C80, 0x0C80, prN}, // Lo KANNADA SIGN SPACING CANDRABINDU - {0x0C81, 0x0C81, prN}, // Mn KANNADA SIGN CANDRABINDU - {0x0C82, 0x0C83, prN}, // Mc [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA - {0x0C84, 0x0C84, prN}, // Po KANNADA SIGN SIDDHAM - {0x0C85, 0x0C8C, prN}, // Lo [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L - {0x0C8E, 0x0C90, prN}, // Lo [3] KANNADA LETTER E..KANNADA LETTER AI - {0x0C92, 0x0CA8, prN}, // Lo [23] KANNADA LETTER O..KANNADA LETTER NA - {0x0CAA, 0x0CB3, prN}, // Lo [10] KANNADA LETTER PA..KANNADA LETTER LLA - {0x0CB5, 0x0CB9, prN}, // Lo [5] KANNADA LETTER VA..KANNADA LETTER HA - {0x0CBC, 0x0CBC, prN}, // Mn KANNADA SIGN NUKTA - {0x0CBD, 0x0CBD, prN}, // Lo KANNADA SIGN AVAGRAHA - {0x0CBE, 0x0CBE, prN}, // Mc KANNADA VOWEL SIGN AA - {0x0CBF, 0x0CBF, prN}, // Mn KANNADA VOWEL SIGN I - {0x0CC0, 0x0CC4, prN}, // Mc [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR - {0x0CC6, 0x0CC6, prN}, // Mn KANNADA VOWEL SIGN E - {0x0CC7, 0x0CC8, prN}, // Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI - {0x0CCA, 0x0CCB, prN}, // Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO - {0x0CCC, 0x0CCD, prN}, // Mn [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA - {0x0CD5, 0x0CD6, prN}, // Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK - {0x0CDD, 0x0CDE, prN}, // Lo [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA - {0x0CE0, 0x0CE1, prN}, // Lo [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL - {0x0CE2, 0x0CE3, prN}, // Mn [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL - {0x0CE6, 0x0CEF, prN}, // Nd [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE - {0x0CF1, 0x0CF2, prN}, // Lo [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA - {0x0CF3, 0x0CF3, prN}, // Mc KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT - {0x0D00, 0x0D01, prN}, // Mn [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU - {0x0D02, 0x0D03, prN}, // Mc [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA - {0x0D04, 0x0D0C, prN}, // Lo [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L - {0x0D0E, 0x0D10, prN}, // Lo [3] MALAYALAM LETTER E..MALAYALAM LETTER AI - {0x0D12, 0x0D3A, prN}, // Lo [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA - {0x0D3B, 0x0D3C, prN}, // Mn [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA - {0x0D3D, 0x0D3D, prN}, // Lo MALAYALAM SIGN AVAGRAHA - {0x0D3E, 0x0D40, prN}, // Mc [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II - {0x0D41, 0x0D44, prN}, // Mn [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR - {0x0D46, 0x0D48, prN}, // Mc [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI - {0x0D4A, 0x0D4C, prN}, // Mc [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU - {0x0D4D, 0x0D4D, prN}, // Mn MALAYALAM SIGN VIRAMA - {0x0D4E, 0x0D4E, prN}, // Lo MALAYALAM LETTER DOT REPH - {0x0D4F, 0x0D4F, prN}, // So MALAYALAM SIGN PARA - {0x0D54, 0x0D56, prN}, // Lo [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL - {0x0D57, 0x0D57, prN}, // Mc MALAYALAM AU LENGTH MARK - {0x0D58, 0x0D5E, prN}, // No [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH - {0x0D5F, 0x0D61, prN}, // Lo [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL - {0x0D62, 0x0D63, prN}, // Mn [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL - {0x0D66, 0x0D6F, prN}, // Nd [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE - {0x0D70, 0x0D78, prN}, // No [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS - {0x0D79, 0x0D79, prN}, // So MALAYALAM DATE MARK - {0x0D7A, 0x0D7F, prN}, // Lo [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K - {0x0D81, 0x0D81, prN}, // Mn SINHALA SIGN CANDRABINDU - {0x0D82, 0x0D83, prN}, // Mc [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA - {0x0D85, 0x0D96, prN}, // Lo [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA - {0x0D9A, 0x0DB1, prN}, // Lo [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA - {0x0DB3, 0x0DBB, prN}, // Lo [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA - {0x0DBD, 0x0DBD, prN}, // Lo SINHALA LETTER DANTAJA LAYANNA - {0x0DC0, 0x0DC6, prN}, // Lo [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA - {0x0DCA, 0x0DCA, prN}, // Mn SINHALA SIGN AL-LAKUNA - {0x0DCF, 0x0DD1, prN}, // Mc [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA - {0x0DD2, 0x0DD4, prN}, // Mn [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA - {0x0DD6, 0x0DD6, prN}, // Mn SINHALA VOWEL SIGN DIGA PAA-PILLA - {0x0DD8, 0x0DDF, prN}, // Mc [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA - {0x0DE6, 0x0DEF, prN}, // Nd [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE - {0x0DF2, 0x0DF3, prN}, // Mc [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA - {0x0DF4, 0x0DF4, prN}, // Po SINHALA PUNCTUATION KUNDDALIYA - {0x0E01, 0x0E30, prN}, // Lo [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A - {0x0E31, 0x0E31, prN}, // Mn THAI CHARACTER MAI HAN-AKAT - {0x0E32, 0x0E33, prN}, // Lo [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM - {0x0E34, 0x0E3A, prN}, // Mn [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU - {0x0E3F, 0x0E3F, prN}, // Sc THAI CURRENCY SYMBOL BAHT - {0x0E40, 0x0E45, prN}, // Lo [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO - {0x0E46, 0x0E46, prN}, // Lm THAI CHARACTER MAIYAMOK - {0x0E47, 0x0E4E, prN}, // Mn [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN - {0x0E4F, 0x0E4F, prN}, // Po THAI CHARACTER FONGMAN - {0x0E50, 0x0E59, prN}, // Nd [10] THAI DIGIT ZERO..THAI DIGIT NINE - {0x0E5A, 0x0E5B, prN}, // Po [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT - {0x0E81, 0x0E82, prN}, // Lo [2] LAO LETTER KO..LAO LETTER KHO SUNG - {0x0E84, 0x0E84, prN}, // Lo LAO LETTER KHO TAM - {0x0E86, 0x0E8A, prN}, // Lo [5] LAO LETTER PALI GHA..LAO LETTER SO TAM - {0x0E8C, 0x0EA3, prN}, // Lo [24] LAO LETTER PALI JHA..LAO LETTER LO LING - {0x0EA5, 0x0EA5, prN}, // Lo LAO LETTER LO LOOT - {0x0EA7, 0x0EB0, prN}, // Lo [10] LAO LETTER WO..LAO VOWEL SIGN A - {0x0EB1, 0x0EB1, prN}, // Mn LAO VOWEL SIGN MAI KAN - {0x0EB2, 0x0EB3, prN}, // Lo [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM - {0x0EB4, 0x0EBC, prN}, // Mn [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO - {0x0EBD, 0x0EBD, prN}, // Lo LAO SEMIVOWEL SIGN NYO - {0x0EC0, 0x0EC4, prN}, // Lo [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI - {0x0EC6, 0x0EC6, prN}, // Lm LAO KO LA - {0x0EC8, 0x0ECE, prN}, // Mn [7] LAO TONE MAI EK..LAO YAMAKKAN - {0x0ED0, 0x0ED9, prN}, // Nd [10] LAO DIGIT ZERO..LAO DIGIT NINE - {0x0EDC, 0x0EDF, prN}, // Lo [4] LAO HO NO..LAO LETTER KHMU NYO - {0x0F00, 0x0F00, prN}, // Lo TIBETAN SYLLABLE OM - {0x0F01, 0x0F03, prN}, // So [3] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA - {0x0F04, 0x0F12, prN}, // Po [15] TIBETAN MARK INITIAL YIG MGO MDUN MA..TIBETAN MARK RGYA GRAM SHAD - {0x0F13, 0x0F13, prN}, // So TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN - {0x0F14, 0x0F14, prN}, // Po TIBETAN MARK GTER TSHEG - {0x0F15, 0x0F17, prN}, // So [3] TIBETAN LOGOTYPE SIGN CHAD RTAGS..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS - {0x0F18, 0x0F19, prN}, // Mn [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS - {0x0F1A, 0x0F1F, prN}, // So [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG - {0x0F20, 0x0F29, prN}, // Nd [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE - {0x0F2A, 0x0F33, prN}, // No [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO - {0x0F34, 0x0F34, prN}, // So TIBETAN MARK BSDUS RTAGS - {0x0F35, 0x0F35, prN}, // Mn TIBETAN MARK NGAS BZUNG NYI ZLA - {0x0F36, 0x0F36, prN}, // So TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN - {0x0F37, 0x0F37, prN}, // Mn TIBETAN MARK NGAS BZUNG SGOR RTAGS - {0x0F38, 0x0F38, prN}, // So TIBETAN MARK CHE MGO - {0x0F39, 0x0F39, prN}, // Mn TIBETAN MARK TSA -PHRU - {0x0F3A, 0x0F3A, prN}, // Ps TIBETAN MARK GUG RTAGS GYON - {0x0F3B, 0x0F3B, prN}, // Pe TIBETAN MARK GUG RTAGS GYAS - {0x0F3C, 0x0F3C, prN}, // Ps TIBETAN MARK ANG KHANG GYON - {0x0F3D, 0x0F3D, prN}, // Pe TIBETAN MARK ANG KHANG GYAS - {0x0F3E, 0x0F3F, prN}, // Mc [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES - {0x0F40, 0x0F47, prN}, // Lo [8] TIBETAN LETTER KA..TIBETAN LETTER JA - {0x0F49, 0x0F6C, prN}, // Lo [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA - {0x0F71, 0x0F7E, prN}, // Mn [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO - {0x0F7F, 0x0F7F, prN}, // Mc TIBETAN SIGN RNAM BCAD - {0x0F80, 0x0F84, prN}, // Mn [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA - {0x0F85, 0x0F85, prN}, // Po TIBETAN MARK PALUTA - {0x0F86, 0x0F87, prN}, // Mn [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS - {0x0F88, 0x0F8C, prN}, // Lo [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN - {0x0F8D, 0x0F97, prN}, // Mn [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA - {0x0F99, 0x0FBC, prN}, // Mn [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA - {0x0FBE, 0x0FC5, prN}, // So [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE - {0x0FC6, 0x0FC6, prN}, // Mn TIBETAN SYMBOL PADMA GDAN - {0x0FC7, 0x0FCC, prN}, // So [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL - {0x0FCE, 0x0FCF, prN}, // So [2] TIBETAN SIGN RDEL NAG RDEL DKAR..TIBETAN SIGN RDEL NAG GSUM - {0x0FD0, 0x0FD4, prN}, // Po [5] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA - {0x0FD5, 0x0FD8, prN}, // So [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS - {0x0FD9, 0x0FDA, prN}, // Po [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS - {0x1000, 0x102A, prN}, // Lo [43] MYANMAR LETTER KA..MYANMAR LETTER AU - {0x102B, 0x102C, prN}, // Mc [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA - {0x102D, 0x1030, prN}, // Mn [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU - {0x1031, 0x1031, prN}, // Mc MYANMAR VOWEL SIGN E - {0x1032, 0x1037, prN}, // Mn [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW - {0x1038, 0x1038, prN}, // Mc MYANMAR SIGN VISARGA - {0x1039, 0x103A, prN}, // Mn [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT - {0x103B, 0x103C, prN}, // Mc [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA - {0x103D, 0x103E, prN}, // Mn [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA - {0x103F, 0x103F, prN}, // Lo MYANMAR LETTER GREAT SA - {0x1040, 0x1049, prN}, // Nd [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE - {0x104A, 0x104F, prN}, // Po [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE - {0x1050, 0x1055, prN}, // Lo [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL - {0x1056, 0x1057, prN}, // Mc [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR - {0x1058, 0x1059, prN}, // Mn [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL - {0x105A, 0x105D, prN}, // Lo [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE - {0x105E, 0x1060, prN}, // Mn [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA - {0x1061, 0x1061, prN}, // Lo MYANMAR LETTER SGAW KAREN SHA - {0x1062, 0x1064, prN}, // Mc [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO - {0x1065, 0x1066, prN}, // Lo [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA - {0x1067, 0x106D, prN}, // Mc [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5 - {0x106E, 0x1070, prN}, // Lo [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA - {0x1071, 0x1074, prN}, // Mn [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE - {0x1075, 0x1081, prN}, // Lo [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA - {0x1082, 0x1082, prN}, // Mn MYANMAR CONSONANT SIGN SHAN MEDIAL WA - {0x1083, 0x1084, prN}, // Mc [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E - {0x1085, 0x1086, prN}, // Mn [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y - {0x1087, 0x108C, prN}, // Mc [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3 - {0x108D, 0x108D, prN}, // Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE - {0x108E, 0x108E, prN}, // Lo MYANMAR LETTER RUMAI PALAUNG FA - {0x108F, 0x108F, prN}, // Mc MYANMAR SIGN RUMAI PALAUNG TONE-5 - {0x1090, 0x1099, prN}, // Nd [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE - {0x109A, 0x109C, prN}, // Mc [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A - {0x109D, 0x109D, prN}, // Mn MYANMAR VOWEL SIGN AITON AI - {0x109E, 0x109F, prN}, // So [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION - {0x10A0, 0x10C5, prN}, // Lu [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE - {0x10C7, 0x10C7, prN}, // Lu GEORGIAN CAPITAL LETTER YN - {0x10CD, 0x10CD, prN}, // Lu GEORGIAN CAPITAL LETTER AEN - {0x10D0, 0x10FA, prN}, // Ll [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN - {0x10FB, 0x10FB, prN}, // Po GEORGIAN PARAGRAPH SEPARATOR - {0x10FC, 0x10FC, prN}, // Lm MODIFIER LETTER GEORGIAN NAR - {0x10FD, 0x10FF, prN}, // Ll [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN - {0x1100, 0x115F, prW}, // Lo [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER - {0x1160, 0x11FF, prN}, // Lo [160] HANGUL JUNGSEONG FILLER..HANGUL JONGSEONG SSANGNIEUN - {0x1200, 0x1248, prN}, // Lo [73] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE QWA - {0x124A, 0x124D, prN}, // Lo [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE - {0x1250, 0x1256, prN}, // Lo [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO - {0x1258, 0x1258, prN}, // Lo ETHIOPIC SYLLABLE QHWA - {0x125A, 0x125D, prN}, // Lo [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE - {0x1260, 0x1288, prN}, // Lo [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA - {0x128A, 0x128D, prN}, // Lo [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE - {0x1290, 0x12B0, prN}, // Lo [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA - {0x12B2, 0x12B5, prN}, // Lo [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE - {0x12B8, 0x12BE, prN}, // Lo [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO - {0x12C0, 0x12C0, prN}, // Lo ETHIOPIC SYLLABLE KXWA - {0x12C2, 0x12C5, prN}, // Lo [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE - {0x12C8, 0x12D6, prN}, // Lo [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O - {0x12D8, 0x1310, prN}, // Lo [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA - {0x1312, 0x1315, prN}, // Lo [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE - {0x1318, 0x135A, prN}, // Lo [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA - {0x135D, 0x135F, prN}, // Mn [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK - {0x1360, 0x1368, prN}, // Po [9] ETHIOPIC SECTION MARK..ETHIOPIC PARAGRAPH SEPARATOR - {0x1369, 0x137C, prN}, // No [20] ETHIOPIC DIGIT ONE..ETHIOPIC NUMBER TEN THOUSAND - {0x1380, 0x138F, prN}, // Lo [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE - {0x1390, 0x1399, prN}, // So [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT - {0x13A0, 0x13F5, prN}, // Lu [86] CHEROKEE LETTER A..CHEROKEE LETTER MV - {0x13F8, 0x13FD, prN}, // Ll [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV - {0x1400, 0x1400, prN}, // Pd CANADIAN SYLLABICS HYPHEN - {0x1401, 0x166C, prN}, // Lo [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA - {0x166D, 0x166D, prN}, // So CANADIAN SYLLABICS CHI SIGN - {0x166E, 0x166E, prN}, // Po CANADIAN SYLLABICS FULL STOP - {0x166F, 0x167F, prN}, // Lo [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W - {0x1680, 0x1680, prN}, // Zs OGHAM SPACE MARK - {0x1681, 0x169A, prN}, // Lo [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH - {0x169B, 0x169B, prN}, // Ps OGHAM FEATHER MARK - {0x169C, 0x169C, prN}, // Pe OGHAM REVERSED FEATHER MARK - {0x16A0, 0x16EA, prN}, // Lo [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X - {0x16EB, 0x16ED, prN}, // Po [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION - {0x16EE, 0x16F0, prN}, // Nl [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL - {0x16F1, 0x16F8, prN}, // Lo [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC - {0x1700, 0x1711, prN}, // Lo [18] TAGALOG LETTER A..TAGALOG LETTER HA - {0x1712, 0x1714, prN}, // Mn [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA - {0x1715, 0x1715, prN}, // Mc TAGALOG SIGN PAMUDPOD - {0x171F, 0x171F, prN}, // Lo TAGALOG LETTER ARCHAIC RA - {0x1720, 0x1731, prN}, // Lo [18] HANUNOO LETTER A..HANUNOO LETTER HA - {0x1732, 0x1733, prN}, // Mn [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U - {0x1734, 0x1734, prN}, // Mc HANUNOO SIGN PAMUDPOD - {0x1735, 0x1736, prN}, // Po [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION - {0x1740, 0x1751, prN}, // Lo [18] BUHID LETTER A..BUHID LETTER HA - {0x1752, 0x1753, prN}, // Mn [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U - {0x1760, 0x176C, prN}, // Lo [13] TAGBANWA LETTER A..TAGBANWA LETTER YA - {0x176E, 0x1770, prN}, // Lo [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA - {0x1772, 0x1773, prN}, // Mn [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U - {0x1780, 0x17B3, prN}, // Lo [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU - {0x17B4, 0x17B5, prN}, // Mn [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA - {0x17B6, 0x17B6, prN}, // Mc KHMER VOWEL SIGN AA - {0x17B7, 0x17BD, prN}, // Mn [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA - {0x17BE, 0x17C5, prN}, // Mc [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU - {0x17C6, 0x17C6, prN}, // Mn KHMER SIGN NIKAHIT - {0x17C7, 0x17C8, prN}, // Mc [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU - {0x17C9, 0x17D3, prN}, // Mn [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT - {0x17D4, 0x17D6, prN}, // Po [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH - {0x17D7, 0x17D7, prN}, // Lm KHMER SIGN LEK TOO - {0x17D8, 0x17DA, prN}, // Po [3] KHMER SIGN BEYYAL..KHMER SIGN KOOMUUT - {0x17DB, 0x17DB, prN}, // Sc KHMER CURRENCY SYMBOL RIEL - {0x17DC, 0x17DC, prN}, // Lo KHMER SIGN AVAKRAHASANYA - {0x17DD, 0x17DD, prN}, // Mn KHMER SIGN ATTHACAN - {0x17E0, 0x17E9, prN}, // Nd [10] KHMER DIGIT ZERO..KHMER DIGIT NINE - {0x17F0, 0x17F9, prN}, // No [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON - {0x1800, 0x1805, prN}, // Po [6] MONGOLIAN BIRGA..MONGOLIAN FOUR DOTS - {0x1806, 0x1806, prN}, // Pd MONGOLIAN TODO SOFT HYPHEN - {0x1807, 0x180A, prN}, // Po [4] MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER..MONGOLIAN NIRUGU - {0x180B, 0x180D, prN}, // Mn [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE - {0x180E, 0x180E, prN}, // Cf MONGOLIAN VOWEL SEPARATOR - {0x180F, 0x180F, prN}, // Mn MONGOLIAN FREE VARIATION SELECTOR FOUR - {0x1810, 0x1819, prN}, // Nd [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE - {0x1820, 0x1842, prN}, // Lo [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI - {0x1843, 0x1843, prN}, // Lm MONGOLIAN LETTER TODO LONG VOWEL SIGN - {0x1844, 0x1878, prN}, // Lo [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS - {0x1880, 0x1884, prN}, // Lo [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA - {0x1885, 0x1886, prN}, // Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA - {0x1887, 0x18A8, prN}, // Lo [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA - {0x18A9, 0x18A9, prN}, // Mn MONGOLIAN LETTER ALI GALI DAGALGA - {0x18AA, 0x18AA, prN}, // Lo MONGOLIAN LETTER MANCHU ALI GALI LHA - {0x18B0, 0x18F5, prN}, // Lo [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S - {0x1900, 0x191E, prN}, // Lo [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA - {0x1920, 0x1922, prN}, // Mn [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U - {0x1923, 0x1926, prN}, // Mc [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU - {0x1927, 0x1928, prN}, // Mn [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O - {0x1929, 0x192B, prN}, // Mc [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA - {0x1930, 0x1931, prN}, // Mc [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA - {0x1932, 0x1932, prN}, // Mn LIMBU SMALL LETTER ANUSVARA - {0x1933, 0x1938, prN}, // Mc [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA - {0x1939, 0x193B, prN}, // Mn [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I - {0x1940, 0x1940, prN}, // So LIMBU SIGN LOO - {0x1944, 0x1945, prN}, // Po [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK - {0x1946, 0x194F, prN}, // Nd [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE - {0x1950, 0x196D, prN}, // Lo [30] TAI LE LETTER KA..TAI LE LETTER AI - {0x1970, 0x1974, prN}, // Lo [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6 - {0x1980, 0x19AB, prN}, // Lo [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA - {0x19B0, 0x19C9, prN}, // Lo [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2 - {0x19D0, 0x19D9, prN}, // Nd [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE - {0x19DA, 0x19DA, prN}, // No NEW TAI LUE THAM DIGIT ONE - {0x19DE, 0x19DF, prN}, // So [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV - {0x19E0, 0x19FF, prN}, // So [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC - {0x1A00, 0x1A16, prN}, // Lo [23] BUGINESE LETTER KA..BUGINESE LETTER HA - {0x1A17, 0x1A18, prN}, // Mn [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U - {0x1A19, 0x1A1A, prN}, // Mc [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O - {0x1A1B, 0x1A1B, prN}, // Mn BUGINESE VOWEL SIGN AE - {0x1A1E, 0x1A1F, prN}, // Po [2] BUGINESE PALLAWA..BUGINESE END OF SECTION - {0x1A20, 0x1A54, prN}, // Lo [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA - {0x1A55, 0x1A55, prN}, // Mc TAI THAM CONSONANT SIGN MEDIAL RA - {0x1A56, 0x1A56, prN}, // Mn TAI THAM CONSONANT SIGN MEDIAL LA - {0x1A57, 0x1A57, prN}, // Mc TAI THAM CONSONANT SIGN LA TANG LAI - {0x1A58, 0x1A5E, prN}, // Mn [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA - {0x1A60, 0x1A60, prN}, // Mn TAI THAM SIGN SAKOT - {0x1A61, 0x1A61, prN}, // Mc TAI THAM VOWEL SIGN A - {0x1A62, 0x1A62, prN}, // Mn TAI THAM VOWEL SIGN MAI SAT - {0x1A63, 0x1A64, prN}, // Mc [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA - {0x1A65, 0x1A6C, prN}, // Mn [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW - {0x1A6D, 0x1A72, prN}, // Mc [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI - {0x1A73, 0x1A7C, prN}, // Mn [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN - {0x1A7F, 0x1A7F, prN}, // Mn TAI THAM COMBINING CRYPTOGRAMMIC DOT - {0x1A80, 0x1A89, prN}, // Nd [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE - {0x1A90, 0x1A99, prN}, // Nd [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE - {0x1AA0, 0x1AA6, prN}, // Po [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA - {0x1AA7, 0x1AA7, prN}, // Lm TAI THAM SIGN MAI YAMOK - {0x1AA8, 0x1AAD, prN}, // Po [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG - {0x1AB0, 0x1ABD, prN}, // Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW - {0x1ABE, 0x1ABE, prN}, // Me COMBINING PARENTHESES OVERLAY - {0x1ABF, 0x1ACE, prN}, // Mn [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T - {0x1B00, 0x1B03, prN}, // Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG - {0x1B04, 0x1B04, prN}, // Mc BALINESE SIGN BISAH - {0x1B05, 0x1B33, prN}, // Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA - {0x1B34, 0x1B34, prN}, // Mn BALINESE SIGN REREKAN - {0x1B35, 0x1B35, prN}, // Mc BALINESE VOWEL SIGN TEDUNG - {0x1B36, 0x1B3A, prN}, // Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA - {0x1B3B, 0x1B3B, prN}, // Mc BALINESE VOWEL SIGN RA REPA TEDUNG - {0x1B3C, 0x1B3C, prN}, // Mn BALINESE VOWEL SIGN LA LENGA - {0x1B3D, 0x1B41, prN}, // Mc [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG - {0x1B42, 0x1B42, prN}, // Mn BALINESE VOWEL SIGN PEPET - {0x1B43, 0x1B44, prN}, // Mc [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG - {0x1B45, 0x1B4C, prN}, // Lo [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA - {0x1B50, 0x1B59, prN}, // Nd [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE - {0x1B5A, 0x1B60, prN}, // Po [7] BALINESE PANTI..BALINESE PAMENENG - {0x1B61, 0x1B6A, prN}, // So [10] BALINESE MUSICAL SYMBOL DONG..BALINESE MUSICAL SYMBOL DANG GEDE - {0x1B6B, 0x1B73, prN}, // Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG - {0x1B74, 0x1B7C, prN}, // So [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING - {0x1B7D, 0x1B7E, prN}, // Po [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG - {0x1B80, 0x1B81, prN}, // Mn [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR - {0x1B82, 0x1B82, prN}, // Mc SUNDANESE SIGN PANGWISAD - {0x1B83, 0x1BA0, prN}, // Lo [30] SUNDANESE LETTER A..SUNDANESE LETTER HA - {0x1BA1, 0x1BA1, prN}, // Mc SUNDANESE CONSONANT SIGN PAMINGKAL - {0x1BA2, 0x1BA5, prN}, // Mn [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU - {0x1BA6, 0x1BA7, prN}, // Mc [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG - {0x1BA8, 0x1BA9, prN}, // Mn [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG - {0x1BAA, 0x1BAA, prN}, // Mc SUNDANESE SIGN PAMAAEH - {0x1BAB, 0x1BAD, prN}, // Mn [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA - {0x1BAE, 0x1BAF, prN}, // Lo [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA - {0x1BB0, 0x1BB9, prN}, // Nd [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE - {0x1BBA, 0x1BBF, prN}, // Lo [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M - {0x1BC0, 0x1BE5, prN}, // Lo [38] BATAK LETTER A..BATAK LETTER U - {0x1BE6, 0x1BE6, prN}, // Mn BATAK SIGN TOMPI - {0x1BE7, 0x1BE7, prN}, // Mc BATAK VOWEL SIGN E - {0x1BE8, 0x1BE9, prN}, // Mn [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE - {0x1BEA, 0x1BEC, prN}, // Mc [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O - {0x1BED, 0x1BED, prN}, // Mn BATAK VOWEL SIGN KARO O - {0x1BEE, 0x1BEE, prN}, // Mc BATAK VOWEL SIGN U - {0x1BEF, 0x1BF1, prN}, // Mn [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H - {0x1BF2, 0x1BF3, prN}, // Mc [2] BATAK PANGOLAT..BATAK PANONGONAN - {0x1BFC, 0x1BFF, prN}, // Po [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT - {0x1C00, 0x1C23, prN}, // Lo [36] LEPCHA LETTER KA..LEPCHA LETTER A - {0x1C24, 0x1C2B, prN}, // Mc [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU - {0x1C2C, 0x1C33, prN}, // Mn [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T - {0x1C34, 0x1C35, prN}, // Mc [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG - {0x1C36, 0x1C37, prN}, // Mn [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA - {0x1C3B, 0x1C3F, prN}, // Po [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK - {0x1C40, 0x1C49, prN}, // Nd [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE - {0x1C4D, 0x1C4F, prN}, // Lo [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA - {0x1C50, 0x1C59, prN}, // Nd [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE - {0x1C5A, 0x1C77, prN}, // Lo [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH - {0x1C78, 0x1C7D, prN}, // Lm [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD - {0x1C7E, 0x1C7F, prN}, // Po [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD - {0x1C80, 0x1C88, prN}, // Ll [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK - {0x1C90, 0x1CBA, prN}, // Lu [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN - {0x1CBD, 0x1CBF, prN}, // Lu [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN - {0x1CC0, 0x1CC7, prN}, // Po [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA - {0x1CD0, 0x1CD2, prN}, // Mn [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA - {0x1CD3, 0x1CD3, prN}, // Po VEDIC SIGN NIHSHVASA - {0x1CD4, 0x1CE0, prN}, // Mn [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA - {0x1CE1, 0x1CE1, prN}, // Mc VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA - {0x1CE2, 0x1CE8, prN}, // Mn [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL - {0x1CE9, 0x1CEC, prN}, // Lo [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL - {0x1CED, 0x1CED, prN}, // Mn VEDIC SIGN TIRYAK - {0x1CEE, 0x1CF3, prN}, // Lo [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA - {0x1CF4, 0x1CF4, prN}, // Mn VEDIC TONE CANDRA ABOVE - {0x1CF5, 0x1CF6, prN}, // Lo [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA - {0x1CF7, 0x1CF7, prN}, // Mc VEDIC SIGN ATIKRAMA - {0x1CF8, 0x1CF9, prN}, // Mn [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE - {0x1CFA, 0x1CFA, prN}, // Lo VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA - {0x1D00, 0x1D2B, prN}, // Ll [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL - {0x1D2C, 0x1D6A, prN}, // Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI - {0x1D6B, 0x1D77, prN}, // Ll [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G - {0x1D78, 0x1D78, prN}, // Lm MODIFIER LETTER CYRILLIC EN - {0x1D79, 0x1D7F, prN}, // Ll [7] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER UPSILON WITH STROKE - {0x1D80, 0x1D9A, prN}, // Ll [27] LATIN SMALL LETTER B WITH PALATAL HOOK..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK - {0x1D9B, 0x1DBF, prN}, // Lm [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA - {0x1DC0, 0x1DFF, prN}, // Mn [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW - {0x1E00, 0x1EFF, prN}, // L& [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP - {0x1F00, 0x1F15, prN}, // L& [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA - {0x1F18, 0x1F1D, prN}, // Lu [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA - {0x1F20, 0x1F45, prN}, // L& [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA - {0x1F48, 0x1F4D, prN}, // Lu [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA - {0x1F50, 0x1F57, prN}, // Ll [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI - {0x1F59, 0x1F59, prN}, // Lu GREEK CAPITAL LETTER UPSILON WITH DASIA - {0x1F5B, 0x1F5B, prN}, // Lu GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA - {0x1F5D, 0x1F5D, prN}, // Lu GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA - {0x1F5F, 0x1F7D, prN}, // L& [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA - {0x1F80, 0x1FB4, prN}, // L& [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI - {0x1FB6, 0x1FBC, prN}, // L& [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI - {0x1FBD, 0x1FBD, prN}, // Sk GREEK KORONIS - {0x1FBE, 0x1FBE, prN}, // Ll GREEK PROSGEGRAMMENI - {0x1FBF, 0x1FC1, prN}, // Sk [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI - {0x1FC2, 0x1FC4, prN}, // Ll [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI - {0x1FC6, 0x1FCC, prN}, // L& [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI - {0x1FCD, 0x1FCF, prN}, // Sk [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI - {0x1FD0, 0x1FD3, prN}, // Ll [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA - {0x1FD6, 0x1FDB, prN}, // L& [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA - {0x1FDD, 0x1FDF, prN}, // Sk [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI - {0x1FE0, 0x1FEC, prN}, // L& [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA - {0x1FED, 0x1FEF, prN}, // Sk [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA - {0x1FF2, 0x1FF4, prN}, // Ll [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI - {0x1FF6, 0x1FFC, prN}, // L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI - {0x1FFD, 0x1FFE, prN}, // Sk [2] GREEK OXIA..GREEK DASIA - {0x2000, 0x200A, prN}, // Zs [11] EN QUAD..HAIR SPACE - {0x200B, 0x200F, prN}, // Cf [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK - {0x2010, 0x2010, prA}, // Pd HYPHEN - {0x2011, 0x2012, prN}, // Pd [2] NON-BREAKING HYPHEN..FIGURE DASH - {0x2013, 0x2015, prA}, // Pd [3] EN DASH..HORIZONTAL BAR - {0x2016, 0x2016, prA}, // Po DOUBLE VERTICAL LINE - {0x2017, 0x2017, prN}, // Po DOUBLE LOW LINE - {0x2018, 0x2018, prA}, // Pi LEFT SINGLE QUOTATION MARK - {0x2019, 0x2019, prA}, // Pf RIGHT SINGLE QUOTATION MARK - {0x201A, 0x201A, prN}, // Ps SINGLE LOW-9 QUOTATION MARK - {0x201B, 0x201B, prN}, // Pi SINGLE HIGH-REVERSED-9 QUOTATION MARK - {0x201C, 0x201C, prA}, // Pi LEFT DOUBLE QUOTATION MARK - {0x201D, 0x201D, prA}, // Pf RIGHT DOUBLE QUOTATION MARK - {0x201E, 0x201E, prN}, // Ps DOUBLE LOW-9 QUOTATION MARK - {0x201F, 0x201F, prN}, // Pi DOUBLE HIGH-REVERSED-9 QUOTATION MARK - {0x2020, 0x2022, prA}, // Po [3] DAGGER..BULLET - {0x2023, 0x2023, prN}, // Po TRIANGULAR BULLET - {0x2024, 0x2027, prA}, // Po [4] ONE DOT LEADER..HYPHENATION POINT - {0x2028, 0x2028, prN}, // Zl LINE SEPARATOR - {0x2029, 0x2029, prN}, // Zp PARAGRAPH SEPARATOR - {0x202A, 0x202E, prN}, // Cf [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE - {0x202F, 0x202F, prN}, // Zs NARROW NO-BREAK SPACE - {0x2030, 0x2030, prA}, // Po PER MILLE SIGN - {0x2031, 0x2031, prN}, // Po PER TEN THOUSAND SIGN - {0x2032, 0x2033, prA}, // Po [2] PRIME..DOUBLE PRIME - {0x2034, 0x2034, prN}, // Po TRIPLE PRIME - {0x2035, 0x2035, prA}, // Po REVERSED PRIME - {0x2036, 0x2038, prN}, // Po [3] REVERSED DOUBLE PRIME..CARET - {0x2039, 0x2039, prN}, // Pi SINGLE LEFT-POINTING ANGLE QUOTATION MARK - {0x203A, 0x203A, prN}, // Pf SINGLE RIGHT-POINTING ANGLE QUOTATION MARK - {0x203B, 0x203B, prA}, // Po REFERENCE MARK - {0x203C, 0x203D, prN}, // Po [2] DOUBLE EXCLAMATION MARK..INTERROBANG - {0x203E, 0x203E, prA}, // Po OVERLINE - {0x203F, 0x2040, prN}, // Pc [2] UNDERTIE..CHARACTER TIE - {0x2041, 0x2043, prN}, // Po [3] CARET INSERTION POINT..HYPHEN BULLET - {0x2044, 0x2044, prN}, // Sm FRACTION SLASH - {0x2045, 0x2045, prN}, // Ps LEFT SQUARE BRACKET WITH QUILL - {0x2046, 0x2046, prN}, // Pe RIGHT SQUARE BRACKET WITH QUILL - {0x2047, 0x2051, prN}, // Po [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY - {0x2052, 0x2052, prN}, // Sm COMMERCIAL MINUS SIGN - {0x2053, 0x2053, prN}, // Po SWUNG DASH - {0x2054, 0x2054, prN}, // Pc INVERTED UNDERTIE - {0x2055, 0x205E, prN}, // Po [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS - {0x205F, 0x205F, prN}, // Zs MEDIUM MATHEMATICAL SPACE - {0x2060, 0x2064, prN}, // Cf [5] WORD JOINER..INVISIBLE PLUS - {0x2066, 0x206F, prN}, // Cf [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES - {0x2070, 0x2070, prN}, // No SUPERSCRIPT ZERO - {0x2071, 0x2071, prN}, // Lm SUPERSCRIPT LATIN SMALL LETTER I - {0x2074, 0x2074, prA}, // No SUPERSCRIPT FOUR - {0x2075, 0x2079, prN}, // No [5] SUPERSCRIPT FIVE..SUPERSCRIPT NINE - {0x207A, 0x207C, prN}, // Sm [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN - {0x207D, 0x207D, prN}, // Ps SUPERSCRIPT LEFT PARENTHESIS - {0x207E, 0x207E, prN}, // Pe SUPERSCRIPT RIGHT PARENTHESIS - {0x207F, 0x207F, prA}, // Lm SUPERSCRIPT LATIN SMALL LETTER N - {0x2080, 0x2080, prN}, // No SUBSCRIPT ZERO - {0x2081, 0x2084, prA}, // No [4] SUBSCRIPT ONE..SUBSCRIPT FOUR - {0x2085, 0x2089, prN}, // No [5] SUBSCRIPT FIVE..SUBSCRIPT NINE - {0x208A, 0x208C, prN}, // Sm [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN - {0x208D, 0x208D, prN}, // Ps SUBSCRIPT LEFT PARENTHESIS - {0x208E, 0x208E, prN}, // Pe SUBSCRIPT RIGHT PARENTHESIS - {0x2090, 0x209C, prN}, // Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T - {0x20A0, 0x20A8, prN}, // Sc [9] EURO-CURRENCY SIGN..RUPEE SIGN - {0x20A9, 0x20A9, prH}, // Sc WON SIGN - {0x20AA, 0x20AB, prN}, // Sc [2] NEW SHEQEL SIGN..DONG SIGN - {0x20AC, 0x20AC, prA}, // Sc EURO SIGN - {0x20AD, 0x20C0, prN}, // Sc [20] KIP SIGN..SOM SIGN - {0x20D0, 0x20DC, prN}, // Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE - {0x20DD, 0x20E0, prN}, // Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH - {0x20E1, 0x20E1, prN}, // Mn COMBINING LEFT RIGHT ARROW ABOVE - {0x20E2, 0x20E4, prN}, // Me [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE - {0x20E5, 0x20F0, prN}, // Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE - {0x2100, 0x2101, prN}, // So [2] ACCOUNT OF..ADDRESSED TO THE SUBJECT - {0x2102, 0x2102, prN}, // Lu DOUBLE-STRUCK CAPITAL C - {0x2103, 0x2103, prA}, // So DEGREE CELSIUS - {0x2104, 0x2104, prN}, // So CENTRE LINE SYMBOL - {0x2105, 0x2105, prA}, // So CARE OF - {0x2106, 0x2106, prN}, // So CADA UNA - {0x2107, 0x2107, prN}, // Lu EULER CONSTANT - {0x2108, 0x2108, prN}, // So SCRUPLE - {0x2109, 0x2109, prA}, // So DEGREE FAHRENHEIT - {0x210A, 0x2112, prN}, // L& [9] SCRIPT SMALL G..SCRIPT CAPITAL L - {0x2113, 0x2113, prA}, // Ll SCRIPT SMALL L - {0x2114, 0x2114, prN}, // So L B BAR SYMBOL - {0x2115, 0x2115, prN}, // Lu DOUBLE-STRUCK CAPITAL N - {0x2116, 0x2116, prA}, // So NUMERO SIGN - {0x2117, 0x2117, prN}, // So SOUND RECORDING COPYRIGHT - {0x2118, 0x2118, prN}, // Sm SCRIPT CAPITAL P - {0x2119, 0x211D, prN}, // Lu [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R - {0x211E, 0x2120, prN}, // So [3] PRESCRIPTION TAKE..SERVICE MARK - {0x2121, 0x2122, prA}, // So [2] TELEPHONE SIGN..TRADE MARK SIGN - {0x2123, 0x2123, prN}, // So VERSICLE - {0x2124, 0x2124, prN}, // Lu DOUBLE-STRUCK CAPITAL Z - {0x2125, 0x2125, prN}, // So OUNCE SIGN - {0x2126, 0x2126, prA}, // Lu OHM SIGN - {0x2127, 0x2127, prN}, // So INVERTED OHM SIGN - {0x2128, 0x2128, prN}, // Lu BLACK-LETTER CAPITAL Z - {0x2129, 0x2129, prN}, // So TURNED GREEK SMALL LETTER IOTA - {0x212A, 0x212A, prN}, // Lu KELVIN SIGN - {0x212B, 0x212B, prA}, // Lu ANGSTROM SIGN - {0x212C, 0x212D, prN}, // Lu [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C - {0x212E, 0x212E, prN}, // So ESTIMATED SYMBOL - {0x212F, 0x2134, prN}, // L& [6] SCRIPT SMALL E..SCRIPT SMALL O - {0x2135, 0x2138, prN}, // Lo [4] ALEF SYMBOL..DALET SYMBOL - {0x2139, 0x2139, prN}, // Ll INFORMATION SOURCE - {0x213A, 0x213B, prN}, // So [2] ROTATED CAPITAL Q..FACSIMILE SIGN - {0x213C, 0x213F, prN}, // L& [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI - {0x2140, 0x2144, prN}, // Sm [5] DOUBLE-STRUCK N-ARY SUMMATION..TURNED SANS-SERIF CAPITAL Y - {0x2145, 0x2149, prN}, // L& [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J - {0x214A, 0x214A, prN}, // So PROPERTY LINE - {0x214B, 0x214B, prN}, // Sm TURNED AMPERSAND - {0x214C, 0x214D, prN}, // So [2] PER SIGN..AKTIESELSKAB - {0x214E, 0x214E, prN}, // Ll TURNED SMALL F - {0x214F, 0x214F, prN}, // So SYMBOL FOR SAMARITAN SOURCE - {0x2150, 0x2152, prN}, // No [3] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE TENTH - {0x2153, 0x2154, prA}, // No [2] VULGAR FRACTION ONE THIRD..VULGAR FRACTION TWO THIRDS - {0x2155, 0x215A, prN}, // No [6] VULGAR FRACTION ONE FIFTH..VULGAR FRACTION FIVE SIXTHS - {0x215B, 0x215E, prA}, // No [4] VULGAR FRACTION ONE EIGHTH..VULGAR FRACTION SEVEN EIGHTHS - {0x215F, 0x215F, prN}, // No FRACTION NUMERATOR ONE - {0x2160, 0x216B, prA}, // Nl [12] ROMAN NUMERAL ONE..ROMAN NUMERAL TWELVE - {0x216C, 0x216F, prN}, // Nl [4] ROMAN NUMERAL FIFTY..ROMAN NUMERAL ONE THOUSAND - {0x2170, 0x2179, prA}, // Nl [10] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL TEN - {0x217A, 0x2182, prN}, // Nl [9] SMALL ROMAN NUMERAL ELEVEN..ROMAN NUMERAL TEN THOUSAND - {0x2183, 0x2184, prN}, // L& [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C - {0x2185, 0x2188, prN}, // Nl [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND - {0x2189, 0x2189, prA}, // No VULGAR FRACTION ZERO THIRDS - {0x218A, 0x218B, prN}, // So [2] TURNED DIGIT TWO..TURNED DIGIT THREE - {0x2190, 0x2194, prA}, // Sm [5] LEFTWARDS ARROW..LEFT RIGHT ARROW - {0x2195, 0x2199, prA}, // So [5] UP DOWN ARROW..SOUTH WEST ARROW - {0x219A, 0x219B, prN}, // Sm [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE - {0x219C, 0x219F, prN}, // So [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW - {0x21A0, 0x21A0, prN}, // Sm RIGHTWARDS TWO HEADED ARROW - {0x21A1, 0x21A2, prN}, // So [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL - {0x21A3, 0x21A3, prN}, // Sm RIGHTWARDS ARROW WITH TAIL - {0x21A4, 0x21A5, prN}, // So [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR - {0x21A6, 0x21A6, prN}, // Sm RIGHTWARDS ARROW FROM BAR - {0x21A7, 0x21AD, prN}, // So [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW - {0x21AE, 0x21AE, prN}, // Sm LEFT RIGHT ARROW WITH STROKE - {0x21AF, 0x21B7, prN}, // So [9] DOWNWARDS ZIGZAG ARROW..CLOCKWISE TOP SEMICIRCLE ARROW - {0x21B8, 0x21B9, prA}, // So [2] NORTH WEST ARROW TO LONG BAR..LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR - {0x21BA, 0x21CD, prN}, // So [20] ANTICLOCKWISE OPEN CIRCLE ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE - {0x21CE, 0x21CF, prN}, // Sm [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE - {0x21D0, 0x21D1, prN}, // So [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW - {0x21D2, 0x21D2, prA}, // Sm RIGHTWARDS DOUBLE ARROW - {0x21D3, 0x21D3, prN}, // So DOWNWARDS DOUBLE ARROW - {0x21D4, 0x21D4, prA}, // Sm LEFT RIGHT DOUBLE ARROW - {0x21D5, 0x21E6, prN}, // So [18] UP DOWN DOUBLE ARROW..LEFTWARDS WHITE ARROW - {0x21E7, 0x21E7, prA}, // So UPWARDS WHITE ARROW - {0x21E8, 0x21F3, prN}, // So [12] RIGHTWARDS WHITE ARROW..UP DOWN WHITE ARROW - {0x21F4, 0x21FF, prN}, // Sm [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW - {0x2200, 0x2200, prA}, // Sm FOR ALL - {0x2201, 0x2201, prN}, // Sm COMPLEMENT - {0x2202, 0x2203, prA}, // Sm [2] PARTIAL DIFFERENTIAL..THERE EXISTS - {0x2204, 0x2206, prN}, // Sm [3] THERE DOES NOT EXIST..INCREMENT - {0x2207, 0x2208, prA}, // Sm [2] NABLA..ELEMENT OF - {0x2209, 0x220A, prN}, // Sm [2] NOT AN ELEMENT OF..SMALL ELEMENT OF - {0x220B, 0x220B, prA}, // Sm CONTAINS AS MEMBER - {0x220C, 0x220E, prN}, // Sm [3] DOES NOT CONTAIN AS MEMBER..END OF PROOF - {0x220F, 0x220F, prA}, // Sm N-ARY PRODUCT - {0x2210, 0x2210, prN}, // Sm N-ARY COPRODUCT - {0x2211, 0x2211, prA}, // Sm N-ARY SUMMATION - {0x2212, 0x2214, prN}, // Sm [3] MINUS SIGN..DOT PLUS - {0x2215, 0x2215, prA}, // Sm DIVISION SLASH - {0x2216, 0x2219, prN}, // Sm [4] SET MINUS..BULLET OPERATOR - {0x221A, 0x221A, prA}, // Sm SQUARE ROOT - {0x221B, 0x221C, prN}, // Sm [2] CUBE ROOT..FOURTH ROOT - {0x221D, 0x2220, prA}, // Sm [4] PROPORTIONAL TO..ANGLE - {0x2221, 0x2222, prN}, // Sm [2] MEASURED ANGLE..SPHERICAL ANGLE - {0x2223, 0x2223, prA}, // Sm DIVIDES - {0x2224, 0x2224, prN}, // Sm DOES NOT DIVIDE - {0x2225, 0x2225, prA}, // Sm PARALLEL TO - {0x2226, 0x2226, prN}, // Sm NOT PARALLEL TO - {0x2227, 0x222C, prA}, // Sm [6] LOGICAL AND..DOUBLE INTEGRAL - {0x222D, 0x222D, prN}, // Sm TRIPLE INTEGRAL - {0x222E, 0x222E, prA}, // Sm CONTOUR INTEGRAL - {0x222F, 0x2233, prN}, // Sm [5] SURFACE INTEGRAL..ANTICLOCKWISE CONTOUR INTEGRAL - {0x2234, 0x2237, prA}, // Sm [4] THEREFORE..PROPORTION - {0x2238, 0x223B, prN}, // Sm [4] DOT MINUS..HOMOTHETIC - {0x223C, 0x223D, prA}, // Sm [2] TILDE OPERATOR..REVERSED TILDE - {0x223E, 0x2247, prN}, // Sm [10] INVERTED LAZY S..NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO - {0x2248, 0x2248, prA}, // Sm ALMOST EQUAL TO - {0x2249, 0x224B, prN}, // Sm [3] NOT ALMOST EQUAL TO..TRIPLE TILDE - {0x224C, 0x224C, prA}, // Sm ALL EQUAL TO - {0x224D, 0x2251, prN}, // Sm [5] EQUIVALENT TO..GEOMETRICALLY EQUAL TO - {0x2252, 0x2252, prA}, // Sm APPROXIMATELY EQUAL TO OR THE IMAGE OF - {0x2253, 0x225F, prN}, // Sm [13] IMAGE OF OR APPROXIMATELY EQUAL TO..QUESTIONED EQUAL TO - {0x2260, 0x2261, prA}, // Sm [2] NOT EQUAL TO..IDENTICAL TO - {0x2262, 0x2263, prN}, // Sm [2] NOT IDENTICAL TO..STRICTLY EQUIVALENT TO - {0x2264, 0x2267, prA}, // Sm [4] LESS-THAN OR EQUAL TO..GREATER-THAN OVER EQUAL TO - {0x2268, 0x2269, prN}, // Sm [2] LESS-THAN BUT NOT EQUAL TO..GREATER-THAN BUT NOT EQUAL TO - {0x226A, 0x226B, prA}, // Sm [2] MUCH LESS-THAN..MUCH GREATER-THAN - {0x226C, 0x226D, prN}, // Sm [2] BETWEEN..NOT EQUIVALENT TO - {0x226E, 0x226F, prA}, // Sm [2] NOT LESS-THAN..NOT GREATER-THAN - {0x2270, 0x2281, prN}, // Sm [18] NEITHER LESS-THAN NOR EQUAL TO..DOES NOT SUCCEED - {0x2282, 0x2283, prA}, // Sm [2] SUBSET OF..SUPERSET OF - {0x2284, 0x2285, prN}, // Sm [2] NOT A SUBSET OF..NOT A SUPERSET OF - {0x2286, 0x2287, prA}, // Sm [2] SUBSET OF OR EQUAL TO..SUPERSET OF OR EQUAL TO - {0x2288, 0x2294, prN}, // Sm [13] NEITHER A SUBSET OF NOR EQUAL TO..SQUARE CUP - {0x2295, 0x2295, prA}, // Sm CIRCLED PLUS - {0x2296, 0x2298, prN}, // Sm [3] CIRCLED MINUS..CIRCLED DIVISION SLASH - {0x2299, 0x2299, prA}, // Sm CIRCLED DOT OPERATOR - {0x229A, 0x22A4, prN}, // Sm [11] CIRCLED RING OPERATOR..DOWN TACK - {0x22A5, 0x22A5, prA}, // Sm UP TACK - {0x22A6, 0x22BE, prN}, // Sm [25] ASSERTION..RIGHT ANGLE WITH ARC - {0x22BF, 0x22BF, prA}, // Sm RIGHT TRIANGLE - {0x22C0, 0x22FF, prN}, // Sm [64] N-ARY LOGICAL AND..Z NOTATION BAG MEMBERSHIP - {0x2300, 0x2307, prN}, // So [8] DIAMETER SIGN..WAVY LINE - {0x2308, 0x2308, prN}, // Ps LEFT CEILING - {0x2309, 0x2309, prN}, // Pe RIGHT CEILING - {0x230A, 0x230A, prN}, // Ps LEFT FLOOR - {0x230B, 0x230B, prN}, // Pe RIGHT FLOOR - {0x230C, 0x2311, prN}, // So [6] BOTTOM RIGHT CROP..SQUARE LOZENGE - {0x2312, 0x2312, prA}, // So ARC - {0x2313, 0x2319, prN}, // So [7] SEGMENT..TURNED NOT SIGN - {0x231A, 0x231B, prW}, // So [2] WATCH..HOURGLASS - {0x231C, 0x231F, prN}, // So [4] TOP LEFT CORNER..BOTTOM RIGHT CORNER - {0x2320, 0x2321, prN}, // Sm [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL - {0x2322, 0x2328, prN}, // So [7] FROWN..KEYBOARD - {0x2329, 0x2329, prW}, // Ps LEFT-POINTING ANGLE BRACKET - {0x232A, 0x232A, prW}, // Pe RIGHT-POINTING ANGLE BRACKET - {0x232B, 0x237B, prN}, // So [81] ERASE TO THE LEFT..NOT CHECK MARK - {0x237C, 0x237C, prN}, // Sm RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW - {0x237D, 0x239A, prN}, // So [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL - {0x239B, 0x23B3, prN}, // Sm [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM - {0x23B4, 0x23DB, prN}, // So [40] TOP SQUARE BRACKET..FUSE - {0x23DC, 0x23E1, prN}, // Sm [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET - {0x23E2, 0x23E8, prN}, // So [7] WHITE TRAPEZIUM..DECIMAL EXPONENT SYMBOL - {0x23E9, 0x23EC, prW}, // So [4] BLACK RIGHT-POINTING DOUBLE TRIANGLE..BLACK DOWN-POINTING DOUBLE TRIANGLE - {0x23ED, 0x23EF, prN}, // So [3] BLACK RIGHT-POINTING DOUBLE TRIANGLE WITH VERTICAL BAR..BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR - {0x23F0, 0x23F0, prW}, // So ALARM CLOCK - {0x23F1, 0x23F2, prN}, // So [2] STOPWATCH..TIMER CLOCK - {0x23F3, 0x23F3, prW}, // So HOURGLASS WITH FLOWING SAND - {0x23F4, 0x23FF, prN}, // So [12] BLACK MEDIUM LEFT-POINTING TRIANGLE..OBSERVER EYE SYMBOL - {0x2400, 0x2426, prN}, // So [39] SYMBOL FOR NULL..SYMBOL FOR SUBSTITUTE FORM TWO - {0x2440, 0x244A, prN}, // So [11] OCR HOOK..OCR DOUBLE BACKSLASH - {0x2460, 0x249B, prA}, // No [60] CIRCLED DIGIT ONE..NUMBER TWENTY FULL STOP - {0x249C, 0x24E9, prA}, // So [78] PARENTHESIZED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z - {0x24EA, 0x24EA, prN}, // No CIRCLED DIGIT ZERO - {0x24EB, 0x24FF, prA}, // No [21] NEGATIVE CIRCLED NUMBER ELEVEN..NEGATIVE CIRCLED DIGIT ZERO - {0x2500, 0x254B, prA}, // So [76] BOX DRAWINGS LIGHT HORIZONTAL..BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL - {0x254C, 0x254F, prN}, // So [4] BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL..BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL - {0x2550, 0x2573, prA}, // So [36] BOX DRAWINGS DOUBLE HORIZONTAL..BOX DRAWINGS LIGHT DIAGONAL CROSS - {0x2574, 0x257F, prN}, // So [12] BOX DRAWINGS LIGHT LEFT..BOX DRAWINGS HEAVY UP AND LIGHT DOWN - {0x2580, 0x258F, prA}, // So [16] UPPER HALF BLOCK..LEFT ONE EIGHTH BLOCK - {0x2590, 0x2591, prN}, // So [2] RIGHT HALF BLOCK..LIGHT SHADE - {0x2592, 0x2595, prA}, // So [4] MEDIUM SHADE..RIGHT ONE EIGHTH BLOCK - {0x2596, 0x259F, prN}, // So [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT - {0x25A0, 0x25A1, prA}, // So [2] BLACK SQUARE..WHITE SQUARE - {0x25A2, 0x25A2, prN}, // So WHITE SQUARE WITH ROUNDED CORNERS - {0x25A3, 0x25A9, prA}, // So [7] WHITE SQUARE CONTAINING BLACK SMALL SQUARE..SQUARE WITH DIAGONAL CROSSHATCH FILL - {0x25AA, 0x25B1, prN}, // So [8] BLACK SMALL SQUARE..WHITE PARALLELOGRAM - {0x25B2, 0x25B3, prA}, // So [2] BLACK UP-POINTING TRIANGLE..WHITE UP-POINTING TRIANGLE - {0x25B4, 0x25B5, prN}, // So [2] BLACK UP-POINTING SMALL TRIANGLE..WHITE UP-POINTING SMALL TRIANGLE - {0x25B6, 0x25B6, prA}, // So BLACK RIGHT-POINTING TRIANGLE - {0x25B7, 0x25B7, prA}, // Sm WHITE RIGHT-POINTING TRIANGLE - {0x25B8, 0x25BB, prN}, // So [4] BLACK RIGHT-POINTING SMALL TRIANGLE..WHITE RIGHT-POINTING POINTER - {0x25BC, 0x25BD, prA}, // So [2] BLACK DOWN-POINTING TRIANGLE..WHITE DOWN-POINTING TRIANGLE - {0x25BE, 0x25BF, prN}, // So [2] BLACK DOWN-POINTING SMALL TRIANGLE..WHITE DOWN-POINTING SMALL TRIANGLE - {0x25C0, 0x25C0, prA}, // So BLACK LEFT-POINTING TRIANGLE - {0x25C1, 0x25C1, prA}, // Sm WHITE LEFT-POINTING TRIANGLE - {0x25C2, 0x25C5, prN}, // So [4] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE LEFT-POINTING POINTER - {0x25C6, 0x25C8, prA}, // So [3] BLACK DIAMOND..WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND - {0x25C9, 0x25CA, prN}, // So [2] FISHEYE..LOZENGE - {0x25CB, 0x25CB, prA}, // So WHITE CIRCLE - {0x25CC, 0x25CD, prN}, // So [2] DOTTED CIRCLE..CIRCLE WITH VERTICAL FILL - {0x25CE, 0x25D1, prA}, // So [4] BULLSEYE..CIRCLE WITH RIGHT HALF BLACK - {0x25D2, 0x25E1, prN}, // So [16] CIRCLE WITH LOWER HALF BLACK..LOWER HALF CIRCLE - {0x25E2, 0x25E5, prA}, // So [4] BLACK LOWER RIGHT TRIANGLE..BLACK UPPER RIGHT TRIANGLE - {0x25E6, 0x25EE, prN}, // So [9] WHITE BULLET..UP-POINTING TRIANGLE WITH RIGHT HALF BLACK - {0x25EF, 0x25EF, prA}, // So LARGE CIRCLE - {0x25F0, 0x25F7, prN}, // So [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT - {0x25F8, 0x25FC, prN}, // Sm [5] UPPER LEFT TRIANGLE..BLACK MEDIUM SQUARE - {0x25FD, 0x25FE, prW}, // Sm [2] WHITE MEDIUM SMALL SQUARE..BLACK MEDIUM SMALL SQUARE - {0x25FF, 0x25FF, prN}, // Sm LOWER RIGHT TRIANGLE - {0x2600, 0x2604, prN}, // So [5] BLACK SUN WITH RAYS..COMET - {0x2605, 0x2606, prA}, // So [2] BLACK STAR..WHITE STAR - {0x2607, 0x2608, prN}, // So [2] LIGHTNING..THUNDERSTORM - {0x2609, 0x2609, prA}, // So SUN - {0x260A, 0x260D, prN}, // So [4] ASCENDING NODE..OPPOSITION - {0x260E, 0x260F, prA}, // So [2] BLACK TELEPHONE..WHITE TELEPHONE - {0x2610, 0x2613, prN}, // So [4] BALLOT BOX..SALTIRE - {0x2614, 0x2615, prW}, // So [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE - {0x2616, 0x261B, prN}, // So [6] WHITE SHOGI PIECE..BLACK RIGHT POINTING INDEX - {0x261C, 0x261C, prA}, // So WHITE LEFT POINTING INDEX - {0x261D, 0x261D, prN}, // So WHITE UP POINTING INDEX - {0x261E, 0x261E, prA}, // So WHITE RIGHT POINTING INDEX - {0x261F, 0x263F, prN}, // So [33] WHITE DOWN POINTING INDEX..MERCURY - {0x2640, 0x2640, prA}, // So FEMALE SIGN - {0x2641, 0x2641, prN}, // So EARTH - {0x2642, 0x2642, prA}, // So MALE SIGN - {0x2643, 0x2647, prN}, // So [5] JUPITER..PLUTO - {0x2648, 0x2653, prW}, // So [12] ARIES..PISCES - {0x2654, 0x265F, prN}, // So [12] WHITE CHESS KING..BLACK CHESS PAWN - {0x2660, 0x2661, prA}, // So [2] BLACK SPADE SUIT..WHITE HEART SUIT - {0x2662, 0x2662, prN}, // So WHITE DIAMOND SUIT - {0x2663, 0x2665, prA}, // So [3] BLACK CLUB SUIT..BLACK HEART SUIT - {0x2666, 0x2666, prN}, // So BLACK DIAMOND SUIT - {0x2667, 0x266A, prA}, // So [4] WHITE CLUB SUIT..EIGHTH NOTE - {0x266B, 0x266B, prN}, // So BEAMED EIGHTH NOTES - {0x266C, 0x266D, prA}, // So [2] BEAMED SIXTEENTH NOTES..MUSIC FLAT SIGN - {0x266E, 0x266E, prN}, // So MUSIC NATURAL SIGN - {0x266F, 0x266F, prA}, // Sm MUSIC SHARP SIGN - {0x2670, 0x267E, prN}, // So [15] WEST SYRIAC CROSS..PERMANENT PAPER SIGN - {0x267F, 0x267F, prW}, // So WHEELCHAIR SYMBOL - {0x2680, 0x2692, prN}, // So [19] DIE FACE-1..HAMMER AND PICK - {0x2693, 0x2693, prW}, // So ANCHOR - {0x2694, 0x269D, prN}, // So [10] CROSSED SWORDS..OUTLINED WHITE STAR - {0x269E, 0x269F, prA}, // So [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT - {0x26A0, 0x26A0, prN}, // So WARNING SIGN - {0x26A1, 0x26A1, prW}, // So HIGH VOLTAGE SIGN - {0x26A2, 0x26A9, prN}, // So [8] DOUBLED FEMALE SIGN..HORIZONTAL MALE WITH STROKE SIGN - {0x26AA, 0x26AB, prW}, // So [2] MEDIUM WHITE CIRCLE..MEDIUM BLACK CIRCLE - {0x26AC, 0x26BC, prN}, // So [17] MEDIUM SMALL WHITE CIRCLE..SESQUIQUADRATE - {0x26BD, 0x26BE, prW}, // So [2] SOCCER BALL..BASEBALL - {0x26BF, 0x26BF, prA}, // So SQUARED KEY - {0x26C0, 0x26C3, prN}, // So [4] WHITE DRAUGHTS MAN..BLACK DRAUGHTS KING - {0x26C4, 0x26C5, prW}, // So [2] SNOWMAN WITHOUT SNOW..SUN BEHIND CLOUD - {0x26C6, 0x26CD, prA}, // So [8] RAIN..DISABLED CAR - {0x26CE, 0x26CE, prW}, // So OPHIUCHUS - {0x26CF, 0x26D3, prA}, // So [5] PICK..CHAINS - {0x26D4, 0x26D4, prW}, // So NO ENTRY - {0x26D5, 0x26E1, prA}, // So [13] ALTERNATE ONE-WAY LEFT WAY TRAFFIC..RESTRICTED LEFT ENTRY-2 - {0x26E2, 0x26E2, prN}, // So ASTRONOMICAL SYMBOL FOR URANUS - {0x26E3, 0x26E3, prA}, // So HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE - {0x26E4, 0x26E7, prN}, // So [4] PENTAGRAM..INVERTED PENTAGRAM - {0x26E8, 0x26E9, prA}, // So [2] BLACK CROSS ON SHIELD..SHINTO SHRINE - {0x26EA, 0x26EA, prW}, // So CHURCH - {0x26EB, 0x26F1, prA}, // So [7] CASTLE..UMBRELLA ON GROUND - {0x26F2, 0x26F3, prW}, // So [2] FOUNTAIN..FLAG IN HOLE - {0x26F4, 0x26F4, prA}, // So FERRY - {0x26F5, 0x26F5, prW}, // So SAILBOAT - {0x26F6, 0x26F9, prA}, // So [4] SQUARE FOUR CORNERS..PERSON WITH BALL - {0x26FA, 0x26FA, prW}, // So TENT - {0x26FB, 0x26FC, prA}, // So [2] JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL - {0x26FD, 0x26FD, prW}, // So FUEL PUMP - {0x26FE, 0x26FF, prA}, // So [2] CUP ON BLACK SQUARE..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE - {0x2700, 0x2704, prN}, // So [5] BLACK SAFETY SCISSORS..WHITE SCISSORS - {0x2705, 0x2705, prW}, // So WHITE HEAVY CHECK MARK - {0x2706, 0x2709, prN}, // So [4] TELEPHONE LOCATION SIGN..ENVELOPE - {0x270A, 0x270B, prW}, // So [2] RAISED FIST..RAISED HAND - {0x270C, 0x2727, prN}, // So [28] VICTORY HAND..WHITE FOUR POINTED STAR - {0x2728, 0x2728, prW}, // So SPARKLES - {0x2729, 0x273C, prN}, // So [20] STRESS OUTLINED WHITE STAR..OPEN CENTRE TEARDROP-SPOKED ASTERISK - {0x273D, 0x273D, prA}, // So HEAVY TEARDROP-SPOKED ASTERISK - {0x273E, 0x274B, prN}, // So [14] SIX PETALLED BLACK AND WHITE FLORETTE..HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK - {0x274C, 0x274C, prW}, // So CROSS MARK - {0x274D, 0x274D, prN}, // So SHADOWED WHITE CIRCLE - {0x274E, 0x274E, prW}, // So NEGATIVE SQUARED CROSS MARK - {0x274F, 0x2752, prN}, // So [4] LOWER RIGHT DROP-SHADOWED WHITE SQUARE..UPPER RIGHT SHADOWED WHITE SQUARE - {0x2753, 0x2755, prW}, // So [3] BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK ORNAMENT - {0x2756, 0x2756, prN}, // So BLACK DIAMOND MINUS WHITE X - {0x2757, 0x2757, prW}, // So HEAVY EXCLAMATION MARK SYMBOL - {0x2758, 0x2767, prN}, // So [16] LIGHT VERTICAL BAR..ROTATED FLORAL HEART BULLET - {0x2768, 0x2768, prN}, // Ps MEDIUM LEFT PARENTHESIS ORNAMENT - {0x2769, 0x2769, prN}, // Pe MEDIUM RIGHT PARENTHESIS ORNAMENT - {0x276A, 0x276A, prN}, // Ps MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT - {0x276B, 0x276B, prN}, // Pe MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT - {0x276C, 0x276C, prN}, // Ps MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x276D, 0x276D, prN}, // Pe MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x276E, 0x276E, prN}, // Ps HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x276F, 0x276F, prN}, // Pe HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x2770, 0x2770, prN}, // Ps HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x2771, 0x2771, prN}, // Pe HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x2772, 0x2772, prN}, // Ps LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT - {0x2773, 0x2773, prN}, // Pe LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT - {0x2774, 0x2774, prN}, // Ps MEDIUM LEFT CURLY BRACKET ORNAMENT - {0x2775, 0x2775, prN}, // Pe MEDIUM RIGHT CURLY BRACKET ORNAMENT - {0x2776, 0x277F, prA}, // No [10] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED NUMBER TEN - {0x2780, 0x2793, prN}, // No [20] DINGBAT CIRCLED SANS-SERIF DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN - {0x2794, 0x2794, prN}, // So HEAVY WIDE-HEADED RIGHTWARDS ARROW - {0x2795, 0x2797, prW}, // So [3] HEAVY PLUS SIGN..HEAVY DIVISION SIGN - {0x2798, 0x27AF, prN}, // So [24] HEAVY SOUTH EAST ARROW..NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW - {0x27B0, 0x27B0, prW}, // So CURLY LOOP - {0x27B1, 0x27BE, prN}, // So [14] NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW..OPEN-OUTLINED RIGHTWARDS ARROW - {0x27BF, 0x27BF, prW}, // So DOUBLE CURLY LOOP - {0x27C0, 0x27C4, prN}, // Sm [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET - {0x27C5, 0x27C5, prN}, // Ps LEFT S-SHAPED BAG DELIMITER - {0x27C6, 0x27C6, prN}, // Pe RIGHT S-SHAPED BAG DELIMITER - {0x27C7, 0x27E5, prN}, // Sm [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK - {0x27E6, 0x27E6, prNa}, // Ps MATHEMATICAL LEFT WHITE SQUARE BRACKET - {0x27E7, 0x27E7, prNa}, // Pe MATHEMATICAL RIGHT WHITE SQUARE BRACKET - {0x27E8, 0x27E8, prNa}, // Ps MATHEMATICAL LEFT ANGLE BRACKET - {0x27E9, 0x27E9, prNa}, // Pe MATHEMATICAL RIGHT ANGLE BRACKET - {0x27EA, 0x27EA, prNa}, // Ps MATHEMATICAL LEFT DOUBLE ANGLE BRACKET - {0x27EB, 0x27EB, prNa}, // Pe MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET - {0x27EC, 0x27EC, prNa}, // Ps MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET - {0x27ED, 0x27ED, prNa}, // Pe MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET - {0x27EE, 0x27EE, prN}, // Ps MATHEMATICAL LEFT FLATTENED PARENTHESIS - {0x27EF, 0x27EF, prN}, // Pe MATHEMATICAL RIGHT FLATTENED PARENTHESIS - {0x27F0, 0x27FF, prN}, // Sm [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW - {0x2800, 0x28FF, prN}, // So [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678 - {0x2900, 0x297F, prN}, // Sm [128] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..DOWN FISH TAIL - {0x2980, 0x2982, prN}, // Sm [3] TRIPLE VERTICAL BAR DELIMITER..Z NOTATION TYPE COLON - {0x2983, 0x2983, prN}, // Ps LEFT WHITE CURLY BRACKET - {0x2984, 0x2984, prN}, // Pe RIGHT WHITE CURLY BRACKET - {0x2985, 0x2985, prNa}, // Ps LEFT WHITE PARENTHESIS - {0x2986, 0x2986, prNa}, // Pe RIGHT WHITE PARENTHESIS - {0x2987, 0x2987, prN}, // Ps Z NOTATION LEFT IMAGE BRACKET - {0x2988, 0x2988, prN}, // Pe Z NOTATION RIGHT IMAGE BRACKET - {0x2989, 0x2989, prN}, // Ps Z NOTATION LEFT BINDING BRACKET - {0x298A, 0x298A, prN}, // Pe Z NOTATION RIGHT BINDING BRACKET - {0x298B, 0x298B, prN}, // Ps LEFT SQUARE BRACKET WITH UNDERBAR - {0x298C, 0x298C, prN}, // Pe RIGHT SQUARE BRACKET WITH UNDERBAR - {0x298D, 0x298D, prN}, // Ps LEFT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x298E, 0x298E, prN}, // Pe RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x298F, 0x298F, prN}, // Ps LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x2990, 0x2990, prN}, // Pe RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x2991, 0x2991, prN}, // Ps LEFT ANGLE BRACKET WITH DOT - {0x2992, 0x2992, prN}, // Pe RIGHT ANGLE BRACKET WITH DOT - {0x2993, 0x2993, prN}, // Ps LEFT ARC LESS-THAN BRACKET - {0x2994, 0x2994, prN}, // Pe RIGHT ARC GREATER-THAN BRACKET - {0x2995, 0x2995, prN}, // Ps DOUBLE LEFT ARC GREATER-THAN BRACKET - {0x2996, 0x2996, prN}, // Pe DOUBLE RIGHT ARC LESS-THAN BRACKET - {0x2997, 0x2997, prN}, // Ps LEFT BLACK TORTOISE SHELL BRACKET - {0x2998, 0x2998, prN}, // Pe RIGHT BLACK TORTOISE SHELL BRACKET - {0x2999, 0x29D7, prN}, // Sm [63] DOTTED FENCE..BLACK HOURGLASS - {0x29D8, 0x29D8, prN}, // Ps LEFT WIGGLY FENCE - {0x29D9, 0x29D9, prN}, // Pe RIGHT WIGGLY FENCE - {0x29DA, 0x29DA, prN}, // Ps LEFT DOUBLE WIGGLY FENCE - {0x29DB, 0x29DB, prN}, // Pe RIGHT DOUBLE WIGGLY FENCE - {0x29DC, 0x29FB, prN}, // Sm [32] INCOMPLETE INFINITY..TRIPLE PLUS - {0x29FC, 0x29FC, prN}, // Ps LEFT-POINTING CURVED ANGLE BRACKET - {0x29FD, 0x29FD, prN}, // Pe RIGHT-POINTING CURVED ANGLE BRACKET - {0x29FE, 0x29FF, prN}, // Sm [2] TINY..MINY - {0x2A00, 0x2AFF, prN}, // Sm [256] N-ARY CIRCLED DOT OPERATOR..N-ARY WHITE VERTICAL BAR - {0x2B00, 0x2B1A, prN}, // So [27] NORTH EAST WHITE ARROW..DOTTED SQUARE - {0x2B1B, 0x2B1C, prW}, // So [2] BLACK LARGE SQUARE..WHITE LARGE SQUARE - {0x2B1D, 0x2B2F, prN}, // So [19] BLACK VERY SMALL SQUARE..WHITE VERTICAL ELLIPSE - {0x2B30, 0x2B44, prN}, // Sm [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET - {0x2B45, 0x2B46, prN}, // So [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW - {0x2B47, 0x2B4C, prN}, // Sm [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR - {0x2B4D, 0x2B4F, prN}, // So [3] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..SHORT BACKSLANTED SOUTH ARROW - {0x2B50, 0x2B50, prW}, // So WHITE MEDIUM STAR - {0x2B51, 0x2B54, prN}, // So [4] BLACK SMALL STAR..WHITE RIGHT-POINTING PENTAGON - {0x2B55, 0x2B55, prW}, // So HEAVY LARGE CIRCLE - {0x2B56, 0x2B59, prA}, // So [4] HEAVY OVAL WITH OVAL INSIDE..HEAVY CIRCLED SALTIRE - {0x2B5A, 0x2B73, prN}, // So [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR - {0x2B76, 0x2B95, prN}, // So [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW - {0x2B97, 0x2BFF, prN}, // So [105] SYMBOL FOR TYPE A ELECTRONICS..HELLSCHREIBER PAUSE SYMBOL - {0x2C00, 0x2C5F, prN}, // L& [96] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI - {0x2C60, 0x2C7B, prN}, // L& [28] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN LETTER SMALL CAPITAL TURNED E - {0x2C7C, 0x2C7D, prN}, // Lm [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V - {0x2C7E, 0x2C7F, prN}, // Lu [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL - {0x2C80, 0x2CE4, prN}, // L& [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI - {0x2CE5, 0x2CEA, prN}, // So [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA - {0x2CEB, 0x2CEE, prN}, // L& [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA - {0x2CEF, 0x2CF1, prN}, // Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS - {0x2CF2, 0x2CF3, prN}, // L& [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI - {0x2CF9, 0x2CFC, prN}, // Po [4] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN VERSE DIVIDER - {0x2CFD, 0x2CFD, prN}, // No COPTIC FRACTION ONE HALF - {0x2CFE, 0x2CFF, prN}, // Po [2] COPTIC FULL STOP..COPTIC MORPHOLOGICAL DIVIDER - {0x2D00, 0x2D25, prN}, // Ll [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE - {0x2D27, 0x2D27, prN}, // Ll GEORGIAN SMALL LETTER YN - {0x2D2D, 0x2D2D, prN}, // Ll GEORGIAN SMALL LETTER AEN - {0x2D30, 0x2D67, prN}, // Lo [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO - {0x2D6F, 0x2D6F, prN}, // Lm TIFINAGH MODIFIER LETTER LABIALIZATION MARK - {0x2D70, 0x2D70, prN}, // Po TIFINAGH SEPARATOR MARK - {0x2D7F, 0x2D7F, prN}, // Mn TIFINAGH CONSONANT JOINER - {0x2D80, 0x2D96, prN}, // Lo [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE - {0x2DA0, 0x2DA6, prN}, // Lo [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO - {0x2DA8, 0x2DAE, prN}, // Lo [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO - {0x2DB0, 0x2DB6, prN}, // Lo [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO - {0x2DB8, 0x2DBE, prN}, // Lo [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO - {0x2DC0, 0x2DC6, prN}, // Lo [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO - {0x2DC8, 0x2DCE, prN}, // Lo [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO - {0x2DD0, 0x2DD6, prN}, // Lo [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO - {0x2DD8, 0x2DDE, prN}, // Lo [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO - {0x2DE0, 0x2DFF, prN}, // Mn [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS - {0x2E00, 0x2E01, prN}, // Po [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER - {0x2E02, 0x2E02, prN}, // Pi LEFT SUBSTITUTION BRACKET - {0x2E03, 0x2E03, prN}, // Pf RIGHT SUBSTITUTION BRACKET - {0x2E04, 0x2E04, prN}, // Pi LEFT DOTTED SUBSTITUTION BRACKET - {0x2E05, 0x2E05, prN}, // Pf RIGHT DOTTED SUBSTITUTION BRACKET - {0x2E06, 0x2E08, prN}, // Po [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER - {0x2E09, 0x2E09, prN}, // Pi LEFT TRANSPOSITION BRACKET - {0x2E0A, 0x2E0A, prN}, // Pf RIGHT TRANSPOSITION BRACKET - {0x2E0B, 0x2E0B, prN}, // Po RAISED SQUARE - {0x2E0C, 0x2E0C, prN}, // Pi LEFT RAISED OMISSION BRACKET - {0x2E0D, 0x2E0D, prN}, // Pf RIGHT RAISED OMISSION BRACKET - {0x2E0E, 0x2E16, prN}, // Po [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE - {0x2E17, 0x2E17, prN}, // Pd DOUBLE OBLIQUE HYPHEN - {0x2E18, 0x2E19, prN}, // Po [2] INVERTED INTERROBANG..PALM BRANCH - {0x2E1A, 0x2E1A, prN}, // Pd HYPHEN WITH DIAERESIS - {0x2E1B, 0x2E1B, prN}, // Po TILDE WITH RING ABOVE - {0x2E1C, 0x2E1C, prN}, // Pi LEFT LOW PARAPHRASE BRACKET - {0x2E1D, 0x2E1D, prN}, // Pf RIGHT LOW PARAPHRASE BRACKET - {0x2E1E, 0x2E1F, prN}, // Po [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW - {0x2E20, 0x2E20, prN}, // Pi LEFT VERTICAL BAR WITH QUILL - {0x2E21, 0x2E21, prN}, // Pf RIGHT VERTICAL BAR WITH QUILL - {0x2E22, 0x2E22, prN}, // Ps TOP LEFT HALF BRACKET - {0x2E23, 0x2E23, prN}, // Pe TOP RIGHT HALF BRACKET - {0x2E24, 0x2E24, prN}, // Ps BOTTOM LEFT HALF BRACKET - {0x2E25, 0x2E25, prN}, // Pe BOTTOM RIGHT HALF BRACKET - {0x2E26, 0x2E26, prN}, // Ps LEFT SIDEWAYS U BRACKET - {0x2E27, 0x2E27, prN}, // Pe RIGHT SIDEWAYS U BRACKET - {0x2E28, 0x2E28, prN}, // Ps LEFT DOUBLE PARENTHESIS - {0x2E29, 0x2E29, prN}, // Pe RIGHT DOUBLE PARENTHESIS - {0x2E2A, 0x2E2E, prN}, // Po [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK - {0x2E2F, 0x2E2F, prN}, // Lm VERTICAL TILDE - {0x2E30, 0x2E39, prN}, // Po [10] RING POINT..TOP HALF SECTION SIGN - {0x2E3A, 0x2E3B, prN}, // Pd [2] TWO-EM DASH..THREE-EM DASH - {0x2E3C, 0x2E3F, prN}, // Po [4] STENOGRAPHIC FULL STOP..CAPITULUM - {0x2E40, 0x2E40, prN}, // Pd DOUBLE HYPHEN - {0x2E41, 0x2E41, prN}, // Po REVERSED COMMA - {0x2E42, 0x2E42, prN}, // Ps DOUBLE LOW-REVERSED-9 QUOTATION MARK - {0x2E43, 0x2E4F, prN}, // Po [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER - {0x2E50, 0x2E51, prN}, // So [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR - {0x2E52, 0x2E54, prN}, // Po [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK - {0x2E55, 0x2E55, prN}, // Ps LEFT SQUARE BRACKET WITH STROKE - {0x2E56, 0x2E56, prN}, // Pe RIGHT SQUARE BRACKET WITH STROKE - {0x2E57, 0x2E57, prN}, // Ps LEFT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E58, 0x2E58, prN}, // Pe RIGHT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E59, 0x2E59, prN}, // Ps TOP HALF LEFT PARENTHESIS - {0x2E5A, 0x2E5A, prN}, // Pe TOP HALF RIGHT PARENTHESIS - {0x2E5B, 0x2E5B, prN}, // Ps BOTTOM HALF LEFT PARENTHESIS - {0x2E5C, 0x2E5C, prN}, // Pe BOTTOM HALF RIGHT PARENTHESIS - {0x2E5D, 0x2E5D, prN}, // Pd OBLIQUE HYPHEN - {0x2E80, 0x2E99, prW}, // So [26] CJK RADICAL REPEAT..CJK RADICAL RAP - {0x2E9B, 0x2EF3, prW}, // So [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE - {0x2F00, 0x2FD5, prW}, // So [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE - {0x2FF0, 0x2FFB, prW}, // So [12] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID - {0x3000, 0x3000, prF}, // Zs IDEOGRAPHIC SPACE - {0x3001, 0x3003, prW}, // Po [3] IDEOGRAPHIC COMMA..DITTO MARK - {0x3004, 0x3004, prW}, // So JAPANESE INDUSTRIAL STANDARD SYMBOL - {0x3005, 0x3005, prW}, // Lm IDEOGRAPHIC ITERATION MARK - {0x3006, 0x3006, prW}, // Lo IDEOGRAPHIC CLOSING MARK - {0x3007, 0x3007, prW}, // Nl IDEOGRAPHIC NUMBER ZERO - {0x3008, 0x3008, prW}, // Ps LEFT ANGLE BRACKET - {0x3009, 0x3009, prW}, // Pe RIGHT ANGLE BRACKET - {0x300A, 0x300A, prW}, // Ps LEFT DOUBLE ANGLE BRACKET - {0x300B, 0x300B, prW}, // Pe RIGHT DOUBLE ANGLE BRACKET - {0x300C, 0x300C, prW}, // Ps LEFT CORNER BRACKET - {0x300D, 0x300D, prW}, // Pe RIGHT CORNER BRACKET - {0x300E, 0x300E, prW}, // Ps LEFT WHITE CORNER BRACKET - {0x300F, 0x300F, prW}, // Pe RIGHT WHITE CORNER BRACKET - {0x3010, 0x3010, prW}, // Ps LEFT BLACK LENTICULAR BRACKET - {0x3011, 0x3011, prW}, // Pe RIGHT BLACK LENTICULAR BRACKET - {0x3012, 0x3013, prW}, // So [2] POSTAL MARK..GETA MARK - {0x3014, 0x3014, prW}, // Ps LEFT TORTOISE SHELL BRACKET - {0x3015, 0x3015, prW}, // Pe RIGHT TORTOISE SHELL BRACKET - {0x3016, 0x3016, prW}, // Ps LEFT WHITE LENTICULAR BRACKET - {0x3017, 0x3017, prW}, // Pe RIGHT WHITE LENTICULAR BRACKET - {0x3018, 0x3018, prW}, // Ps LEFT WHITE TORTOISE SHELL BRACKET - {0x3019, 0x3019, prW}, // Pe RIGHT WHITE TORTOISE SHELL BRACKET - {0x301A, 0x301A, prW}, // Ps LEFT WHITE SQUARE BRACKET - {0x301B, 0x301B, prW}, // Pe RIGHT WHITE SQUARE BRACKET - {0x301C, 0x301C, prW}, // Pd WAVE DASH - {0x301D, 0x301D, prW}, // Ps REVERSED DOUBLE PRIME QUOTATION MARK - {0x301E, 0x301F, prW}, // Pe [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK - {0x3020, 0x3020, prW}, // So POSTAL MARK FACE - {0x3021, 0x3029, prW}, // Nl [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE - {0x302A, 0x302D, prW}, // Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK - {0x302E, 0x302F, prW}, // Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK - {0x3030, 0x3030, prW}, // Pd WAVY DASH - {0x3031, 0x3035, prW}, // Lm [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF - {0x3036, 0x3037, prW}, // So [2] CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL - {0x3038, 0x303A, prW}, // Nl [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY - {0x303B, 0x303B, prW}, // Lm VERTICAL IDEOGRAPHIC ITERATION MARK - {0x303C, 0x303C, prW}, // Lo MASU MARK - {0x303D, 0x303D, prW}, // Po PART ALTERNATION MARK - {0x303E, 0x303E, prW}, // So IDEOGRAPHIC VARIATION INDICATOR - {0x303F, 0x303F, prN}, // So IDEOGRAPHIC HALF FILL SPACE - {0x3041, 0x3096, prW}, // Lo [86] HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE - {0x3099, 0x309A, prW}, // Mn [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309B, 0x309C, prW}, // Sk [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309D, 0x309E, prW}, // Lm [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK - {0x309F, 0x309F, prW}, // Lo HIRAGANA DIGRAPH YORI - {0x30A0, 0x30A0, prW}, // Pd KATAKANA-HIRAGANA DOUBLE HYPHEN - {0x30A1, 0x30FA, prW}, // Lo [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO - {0x30FB, 0x30FB, prW}, // Po KATAKANA MIDDLE DOT - {0x30FC, 0x30FE, prW}, // Lm [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK - {0x30FF, 0x30FF, prW}, // Lo KATAKANA DIGRAPH KOTO - {0x3105, 0x312F, prW}, // Lo [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN - {0x3131, 0x318E, prW}, // Lo [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE - {0x3190, 0x3191, prW}, // So [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK - {0x3192, 0x3195, prW}, // No [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK - {0x3196, 0x319F, prW}, // So [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK - {0x31A0, 0x31BF, prW}, // Lo [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH - {0x31C0, 0x31E3, prW}, // So [36] CJK STROKE T..CJK STROKE Q - {0x31F0, 0x31FF, prW}, // Lo [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO - {0x3200, 0x321E, prW}, // So [31] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED KOREAN CHARACTER O HU - {0x3220, 0x3229, prW}, // No [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN - {0x322A, 0x3247, prW}, // So [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO - {0x3248, 0x324F, prA}, // No [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE - {0x3250, 0x3250, prW}, // So PARTNERSHIP SIGN - {0x3251, 0x325F, prW}, // No [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE - {0x3260, 0x327F, prW}, // So [32] CIRCLED HANGUL KIYEOK..KOREAN STANDARD SYMBOL - {0x3280, 0x3289, prW}, // No [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN - {0x328A, 0x32B0, prW}, // So [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT - {0x32B1, 0x32BF, prW}, // No [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY - {0x32C0, 0x32FF, prW}, // So [64] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..SQUARE ERA NAME REIWA - {0x3300, 0x33FF, prW}, // So [256] SQUARE APAATO..SQUARE GAL - {0x3400, 0x4DBF, prW}, // Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF - {0x4DC0, 0x4DFF, prN}, // So [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION - {0x4E00, 0x9FFF, prW}, // Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF - {0xA000, 0xA014, prW}, // Lo [21] YI SYLLABLE IT..YI SYLLABLE E - {0xA015, 0xA015, prW}, // Lm YI SYLLABLE WU - {0xA016, 0xA48C, prW}, // Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR - {0xA490, 0xA4C6, prW}, // So [55] YI RADICAL QOT..YI RADICAL KE - {0xA4D0, 0xA4F7, prN}, // Lo [40] LISU LETTER BA..LISU LETTER OE - {0xA4F8, 0xA4FD, prN}, // Lm [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU - {0xA4FE, 0xA4FF, prN}, // Po [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP - {0xA500, 0xA60B, prN}, // Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG - {0xA60C, 0xA60C, prN}, // Lm VAI SYLLABLE LENGTHENER - {0xA60D, 0xA60F, prN}, // Po [3] VAI COMMA..VAI QUESTION MARK - {0xA610, 0xA61F, prN}, // Lo [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG - {0xA620, 0xA629, prN}, // Nd [10] VAI DIGIT ZERO..VAI DIGIT NINE - {0xA62A, 0xA62B, prN}, // Lo [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO - {0xA640, 0xA66D, prN}, // L& [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O - {0xA66E, 0xA66E, prN}, // Lo CYRILLIC LETTER MULTIOCULAR O - {0xA66F, 0xA66F, prN}, // Mn COMBINING CYRILLIC VZMET - {0xA670, 0xA672, prN}, // Me [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN - {0xA673, 0xA673, prN}, // Po SLAVONIC ASTERISK - {0xA674, 0xA67D, prN}, // Mn [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK - {0xA67E, 0xA67E, prN}, // Po CYRILLIC KAVYKA - {0xA67F, 0xA67F, prN}, // Lm CYRILLIC PAYEROK - {0xA680, 0xA69B, prN}, // L& [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O - {0xA69C, 0xA69D, prN}, // Lm [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN - {0xA69E, 0xA69F, prN}, // Mn [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E - {0xA6A0, 0xA6E5, prN}, // Lo [70] BAMUM LETTER A..BAMUM LETTER KI - {0xA6E6, 0xA6EF, prN}, // Nl [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM - {0xA6F0, 0xA6F1, prN}, // Mn [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS - {0xA6F2, 0xA6F7, prN}, // Po [6] BAMUM NJAEMLI..BAMUM QUESTION MARK - {0xA700, 0xA716, prN}, // Sk [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR - {0xA717, 0xA71F, prN}, // Lm [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK - {0xA720, 0xA721, prN}, // Sk [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE - {0xA722, 0xA76F, prN}, // L& [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON - {0xA770, 0xA770, prN}, // Lm MODIFIER LETTER US - {0xA771, 0xA787, prN}, // L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T - {0xA788, 0xA788, prN}, // Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT - {0xA789, 0xA78A, prN}, // Sk [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN - {0xA78B, 0xA78E, prN}, // L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT - {0xA78F, 0xA78F, prN}, // Lo LATIN LETTER SINOLOGICAL DOT - {0xA790, 0xA7CA, prN}, // L& [59] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY - {0xA7D0, 0xA7D1, prN}, // L& [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G - {0xA7D3, 0xA7D3, prN}, // Ll LATIN SMALL LETTER DOUBLE THORN - {0xA7D5, 0xA7D9, prN}, // L& [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S - {0xA7F2, 0xA7F4, prN}, // Lm [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q - {0xA7F5, 0xA7F6, prN}, // L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H - {0xA7F7, 0xA7F7, prN}, // Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I - {0xA7F8, 0xA7F9, prN}, // Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE - {0xA7FA, 0xA7FA, prN}, // Ll LATIN LETTER SMALL CAPITAL TURNED M - {0xA7FB, 0xA7FF, prN}, // Lo [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M - {0xA800, 0xA801, prN}, // Lo [2] SYLOTI NAGRI LETTER A..SYLOTI NAGRI LETTER I - {0xA802, 0xA802, prN}, // Mn SYLOTI NAGRI SIGN DVISVARA - {0xA803, 0xA805, prN}, // Lo [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O - {0xA806, 0xA806, prN}, // Mn SYLOTI NAGRI SIGN HASANTA - {0xA807, 0xA80A, prN}, // Lo [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO - {0xA80B, 0xA80B, prN}, // Mn SYLOTI NAGRI SIGN ANUSVARA - {0xA80C, 0xA822, prN}, // Lo [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO - {0xA823, 0xA824, prN}, // Mc [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I - {0xA825, 0xA826, prN}, // Mn [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E - {0xA827, 0xA827, prN}, // Mc SYLOTI NAGRI VOWEL SIGN OO - {0xA828, 0xA82B, prN}, // So [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4 - {0xA82C, 0xA82C, prN}, // Mn SYLOTI NAGRI SIGN ALTERNATE HASANTA - {0xA830, 0xA835, prN}, // No [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS - {0xA836, 0xA837, prN}, // So [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK - {0xA838, 0xA838, prN}, // Sc NORTH INDIC RUPEE MARK - {0xA839, 0xA839, prN}, // So NORTH INDIC QUANTITY MARK - {0xA840, 0xA873, prN}, // Lo [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU - {0xA874, 0xA877, prN}, // Po [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD - {0xA880, 0xA881, prN}, // Mc [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA - {0xA882, 0xA8B3, prN}, // Lo [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA - {0xA8B4, 0xA8C3, prN}, // Mc [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU - {0xA8C4, 0xA8C5, prN}, // Mn [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU - {0xA8CE, 0xA8CF, prN}, // Po [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA - {0xA8D0, 0xA8D9, prN}, // Nd [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE - {0xA8E0, 0xA8F1, prN}, // Mn [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA - {0xA8F2, 0xA8F7, prN}, // Lo [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA - {0xA8F8, 0xA8FA, prN}, // Po [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET - {0xA8FB, 0xA8FB, prN}, // Lo DEVANAGARI HEADSTROKE - {0xA8FC, 0xA8FC, prN}, // Po DEVANAGARI SIGN SIDDHAM - {0xA8FD, 0xA8FE, prN}, // Lo [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY - {0xA8FF, 0xA8FF, prN}, // Mn DEVANAGARI VOWEL SIGN AY - {0xA900, 0xA909, prN}, // Nd [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE - {0xA90A, 0xA925, prN}, // Lo [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO - {0xA926, 0xA92D, prN}, // Mn [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU - {0xA92E, 0xA92F, prN}, // Po [2] KAYAH LI SIGN CWI..KAYAH LI SIGN SHYA - {0xA930, 0xA946, prN}, // Lo [23] REJANG LETTER KA..REJANG LETTER A - {0xA947, 0xA951, prN}, // Mn [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R - {0xA952, 0xA953, prN}, // Mc [2] REJANG CONSONANT SIGN H..REJANG VIRAMA - {0xA95F, 0xA95F, prN}, // Po REJANG SECTION MARK - {0xA960, 0xA97C, prW}, // Lo [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH - {0xA980, 0xA982, prN}, // Mn [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR - {0xA983, 0xA983, prN}, // Mc JAVANESE SIGN WIGNYAN - {0xA984, 0xA9B2, prN}, // Lo [47] JAVANESE LETTER A..JAVANESE LETTER HA - {0xA9B3, 0xA9B3, prN}, // Mn JAVANESE SIGN CECAK TELU - {0xA9B4, 0xA9B5, prN}, // Mc [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG - {0xA9B6, 0xA9B9, prN}, // Mn [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT - {0xA9BA, 0xA9BB, prN}, // Mc [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE - {0xA9BC, 0xA9BD, prN}, // Mn [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET - {0xA9BE, 0xA9C0, prN}, // Mc [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON - {0xA9C1, 0xA9CD, prN}, // Po [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH - {0xA9CF, 0xA9CF, prN}, // Lm JAVANESE PANGRANGKEP - {0xA9D0, 0xA9D9, prN}, // Nd [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE - {0xA9DE, 0xA9DF, prN}, // Po [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN - {0xA9E0, 0xA9E4, prN}, // Lo [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA - {0xA9E5, 0xA9E5, prN}, // Mn MYANMAR SIGN SHAN SAW - {0xA9E6, 0xA9E6, prN}, // Lm MYANMAR MODIFIER LETTER SHAN REDUPLICATION - {0xA9E7, 0xA9EF, prN}, // Lo [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA - {0xA9F0, 0xA9F9, prN}, // Nd [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE - {0xA9FA, 0xA9FE, prN}, // Lo [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA - {0xAA00, 0xAA28, prN}, // Lo [41] CHAM LETTER A..CHAM LETTER HA - {0xAA29, 0xAA2E, prN}, // Mn [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE - {0xAA2F, 0xAA30, prN}, // Mc [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI - {0xAA31, 0xAA32, prN}, // Mn [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE - {0xAA33, 0xAA34, prN}, // Mc [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA - {0xAA35, 0xAA36, prN}, // Mn [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA - {0xAA40, 0xAA42, prN}, // Lo [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG - {0xAA43, 0xAA43, prN}, // Mn CHAM CONSONANT SIGN FINAL NG - {0xAA44, 0xAA4B, prN}, // Lo [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS - {0xAA4C, 0xAA4C, prN}, // Mn CHAM CONSONANT SIGN FINAL M - {0xAA4D, 0xAA4D, prN}, // Mc CHAM CONSONANT SIGN FINAL H - {0xAA50, 0xAA59, prN}, // Nd [10] CHAM DIGIT ZERO..CHAM DIGIT NINE - {0xAA5C, 0xAA5F, prN}, // Po [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA - {0xAA60, 0xAA6F, prN}, // Lo [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA - {0xAA70, 0xAA70, prN}, // Lm MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION - {0xAA71, 0xAA76, prN}, // Lo [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM - {0xAA77, 0xAA79, prN}, // So [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO - {0xAA7A, 0xAA7A, prN}, // Lo MYANMAR LETTER AITON RA - {0xAA7B, 0xAA7B, prN}, // Mc MYANMAR SIGN PAO KAREN TONE - {0xAA7C, 0xAA7C, prN}, // Mn MYANMAR SIGN TAI LAING TONE-2 - {0xAA7D, 0xAA7D, prN}, // Mc MYANMAR SIGN TAI LAING TONE-5 - {0xAA7E, 0xAA7F, prN}, // Lo [2] MYANMAR LETTER SHWE PALAUNG CHA..MYANMAR LETTER SHWE PALAUNG SHA - {0xAA80, 0xAAAF, prN}, // Lo [48] TAI VIET LETTER LOW KO..TAI VIET LETTER HIGH O - {0xAAB0, 0xAAB0, prN}, // Mn TAI VIET MAI KANG - {0xAAB1, 0xAAB1, prN}, // Lo TAI VIET VOWEL AA - {0xAAB2, 0xAAB4, prN}, // Mn [3] TAI VIET VOWEL I..TAI VIET VOWEL U - {0xAAB5, 0xAAB6, prN}, // Lo [2] TAI VIET VOWEL E..TAI VIET VOWEL O - {0xAAB7, 0xAAB8, prN}, // Mn [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA - {0xAAB9, 0xAABD, prN}, // Lo [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN - {0xAABE, 0xAABF, prN}, // Mn [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK - {0xAAC0, 0xAAC0, prN}, // Lo TAI VIET TONE MAI NUENG - {0xAAC1, 0xAAC1, prN}, // Mn TAI VIET TONE MAI THO - {0xAAC2, 0xAAC2, prN}, // Lo TAI VIET TONE MAI SONG - {0xAADB, 0xAADC, prN}, // Lo [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG - {0xAADD, 0xAADD, prN}, // Lm TAI VIET SYMBOL SAM - {0xAADE, 0xAADF, prN}, // Po [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI - {0xAAE0, 0xAAEA, prN}, // Lo [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA - {0xAAEB, 0xAAEB, prN}, // Mc MEETEI MAYEK VOWEL SIGN II - {0xAAEC, 0xAAED, prN}, // Mn [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI - {0xAAEE, 0xAAEF, prN}, // Mc [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU - {0xAAF0, 0xAAF1, prN}, // Po [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM - {0xAAF2, 0xAAF2, prN}, // Lo MEETEI MAYEK ANJI - {0xAAF3, 0xAAF4, prN}, // Lm [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK - {0xAAF5, 0xAAF5, prN}, // Mc MEETEI MAYEK VOWEL SIGN VISARGA - {0xAAF6, 0xAAF6, prN}, // Mn MEETEI MAYEK VIRAMA - {0xAB01, 0xAB06, prN}, // Lo [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO - {0xAB09, 0xAB0E, prN}, // Lo [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO - {0xAB11, 0xAB16, prN}, // Lo [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO - {0xAB20, 0xAB26, prN}, // Lo [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO - {0xAB28, 0xAB2E, prN}, // Lo [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO - {0xAB30, 0xAB5A, prN}, // Ll [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG - {0xAB5B, 0xAB5B, prN}, // Sk MODIFIER BREVE WITH INVERTED BREVE - {0xAB5C, 0xAB5F, prN}, // Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK - {0xAB60, 0xAB68, prN}, // Ll [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE - {0xAB69, 0xAB69, prN}, // Lm MODIFIER LETTER SMALL TURNED W - {0xAB6A, 0xAB6B, prN}, // Sk [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK - {0xAB70, 0xABBF, prN}, // Ll [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA - {0xABC0, 0xABE2, prN}, // Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM - {0xABE3, 0xABE4, prN}, // Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP - {0xABE5, 0xABE5, prN}, // Mn MEETEI MAYEK VOWEL SIGN ANAP - {0xABE6, 0xABE7, prN}, // Mc [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP - {0xABE8, 0xABE8, prN}, // Mn MEETEI MAYEK VOWEL SIGN UNAP - {0xABE9, 0xABEA, prN}, // Mc [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG - {0xABEB, 0xABEB, prN}, // Po MEETEI MAYEK CHEIKHEI - {0xABEC, 0xABEC, prN}, // Mc MEETEI MAYEK LUM IYEK - {0xABED, 0xABED, prN}, // Mn MEETEI MAYEK APUN IYEK - {0xABF0, 0xABF9, prN}, // Nd [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE - {0xAC00, 0xD7A3, prW}, // Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH - {0xD7B0, 0xD7C6, prN}, // Lo [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E - {0xD7CB, 0xD7FB, prN}, // Lo [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH - {0xD800, 0xDB7F, prN}, // Cs [896] .. - {0xDB80, 0xDBFF, prN}, // Cs [128] .. - {0xDC00, 0xDFFF, prN}, // Cs [1024] .. - {0xE000, 0xF8FF, prA}, // Co [6400] .. - {0xF900, 0xFA6D, prW}, // Lo [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D - {0xFA6E, 0xFA6F, prW}, // Cn [2] .. - {0xFA70, 0xFAD9, prW}, // Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9 - {0xFADA, 0xFAFF, prW}, // Cn [38] .. - {0xFB00, 0xFB06, prN}, // Ll [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST - {0xFB13, 0xFB17, prN}, // Ll [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH - {0xFB1D, 0xFB1D, prN}, // Lo HEBREW LETTER YOD WITH HIRIQ - {0xFB1E, 0xFB1E, prN}, // Mn HEBREW POINT JUDEO-SPANISH VARIKA - {0xFB1F, 0xFB28, prN}, // Lo [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV - {0xFB29, 0xFB29, prN}, // Sm HEBREW LETTER ALTERNATIVE PLUS SIGN - {0xFB2A, 0xFB36, prN}, // Lo [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH - {0xFB38, 0xFB3C, prN}, // Lo [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH - {0xFB3E, 0xFB3E, prN}, // Lo HEBREW LETTER MEM WITH DAGESH - {0xFB40, 0xFB41, prN}, // Lo [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH - {0xFB43, 0xFB44, prN}, // Lo [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH - {0xFB46, 0xFB4F, prN}, // Lo [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED - {0xFB50, 0xFBB1, prN}, // Lo [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM - {0xFBB2, 0xFBC2, prN}, // Sk [17] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL WASLA ABOVE - {0xFBD3, 0xFD3D, prN}, // Lo [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM - {0xFD3E, 0xFD3E, prN}, // Pe ORNATE LEFT PARENTHESIS - {0xFD3F, 0xFD3F, prN}, // Ps ORNATE RIGHT PARENTHESIS - {0xFD40, 0xFD4F, prN}, // So [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH - {0xFD50, 0xFD8F, prN}, // Lo [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM - {0xFD92, 0xFDC7, prN}, // Lo [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM - {0xFDCF, 0xFDCF, prN}, // So ARABIC LIGATURE SALAAMUHU ALAYNAA - {0xFDF0, 0xFDFB, prN}, // Lo [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU - {0xFDFC, 0xFDFC, prN}, // Sc RIAL SIGN - {0xFDFD, 0xFDFF, prN}, // So [3] ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM..ARABIC LIGATURE AZZA WA JALL - {0xFE00, 0xFE0F, prA}, // Mn [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16 - {0xFE10, 0xFE16, prW}, // Po [7] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL QUESTION MARK - {0xFE17, 0xFE17, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET - {0xFE18, 0xFE18, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET - {0xFE19, 0xFE19, prW}, // Po PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS - {0xFE20, 0xFE2F, prN}, // Mn [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF - {0xFE30, 0xFE30, prW}, // Po PRESENTATION FORM FOR VERTICAL TWO DOT LEADER - {0xFE31, 0xFE32, prW}, // Pd [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH - {0xFE33, 0xFE34, prW}, // Pc [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE - {0xFE35, 0xFE35, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS - {0xFE36, 0xFE36, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS - {0xFE37, 0xFE37, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET - {0xFE38, 0xFE38, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET - {0xFE39, 0xFE39, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET - {0xFE3A, 0xFE3A, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET - {0xFE3B, 0xFE3B, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET - {0xFE3C, 0xFE3C, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET - {0xFE3D, 0xFE3D, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET - {0xFE3E, 0xFE3E, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET - {0xFE3F, 0xFE3F, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET - {0xFE40, 0xFE40, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET - {0xFE41, 0xFE41, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET - {0xFE42, 0xFE42, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET - {0xFE43, 0xFE43, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET - {0xFE44, 0xFE44, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET - {0xFE45, 0xFE46, prW}, // Po [2] SESAME DOT..WHITE SESAME DOT - {0xFE47, 0xFE47, prW}, // Ps PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET - {0xFE48, 0xFE48, prW}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET - {0xFE49, 0xFE4C, prW}, // Po [4] DASHED OVERLINE..DOUBLE WAVY OVERLINE - {0xFE4D, 0xFE4F, prW}, // Pc [3] DASHED LOW LINE..WAVY LOW LINE - {0xFE50, 0xFE52, prW}, // Po [3] SMALL COMMA..SMALL FULL STOP - {0xFE54, 0xFE57, prW}, // Po [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK - {0xFE58, 0xFE58, prW}, // Pd SMALL EM DASH - {0xFE59, 0xFE59, prW}, // Ps SMALL LEFT PARENTHESIS - {0xFE5A, 0xFE5A, prW}, // Pe SMALL RIGHT PARENTHESIS - {0xFE5B, 0xFE5B, prW}, // Ps SMALL LEFT CURLY BRACKET - {0xFE5C, 0xFE5C, prW}, // Pe SMALL RIGHT CURLY BRACKET - {0xFE5D, 0xFE5D, prW}, // Ps SMALL LEFT TORTOISE SHELL BRACKET - {0xFE5E, 0xFE5E, prW}, // Pe SMALL RIGHT TORTOISE SHELL BRACKET - {0xFE5F, 0xFE61, prW}, // Po [3] SMALL NUMBER SIGN..SMALL ASTERISK - {0xFE62, 0xFE62, prW}, // Sm SMALL PLUS SIGN - {0xFE63, 0xFE63, prW}, // Pd SMALL HYPHEN-MINUS - {0xFE64, 0xFE66, prW}, // Sm [3] SMALL LESS-THAN SIGN..SMALL EQUALS SIGN - {0xFE68, 0xFE68, prW}, // Po SMALL REVERSE SOLIDUS - {0xFE69, 0xFE69, prW}, // Sc SMALL DOLLAR SIGN - {0xFE6A, 0xFE6B, prW}, // Po [2] SMALL PERCENT SIGN..SMALL COMMERCIAL AT - {0xFE70, 0xFE74, prN}, // Lo [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM - {0xFE76, 0xFEFC, prN}, // Lo [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM - {0xFEFF, 0xFEFF, prN}, // Cf ZERO WIDTH NO-BREAK SPACE - {0xFF01, 0xFF03, prF}, // Po [3] FULLWIDTH EXCLAMATION MARK..FULLWIDTH NUMBER SIGN - {0xFF04, 0xFF04, prF}, // Sc FULLWIDTH DOLLAR SIGN - {0xFF05, 0xFF07, prF}, // Po [3] FULLWIDTH PERCENT SIGN..FULLWIDTH APOSTROPHE - {0xFF08, 0xFF08, prF}, // Ps FULLWIDTH LEFT PARENTHESIS - {0xFF09, 0xFF09, prF}, // Pe FULLWIDTH RIGHT PARENTHESIS - {0xFF0A, 0xFF0A, prF}, // Po FULLWIDTH ASTERISK - {0xFF0B, 0xFF0B, prF}, // Sm FULLWIDTH PLUS SIGN - {0xFF0C, 0xFF0C, prF}, // Po FULLWIDTH COMMA - {0xFF0D, 0xFF0D, prF}, // Pd FULLWIDTH HYPHEN-MINUS - {0xFF0E, 0xFF0F, prF}, // Po [2] FULLWIDTH FULL STOP..FULLWIDTH SOLIDUS - {0xFF10, 0xFF19, prF}, // Nd [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE - {0xFF1A, 0xFF1B, prF}, // Po [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON - {0xFF1C, 0xFF1E, prF}, // Sm [3] FULLWIDTH LESS-THAN SIGN..FULLWIDTH GREATER-THAN SIGN - {0xFF1F, 0xFF20, prF}, // Po [2] FULLWIDTH QUESTION MARK..FULLWIDTH COMMERCIAL AT - {0xFF21, 0xFF3A, prF}, // Lu [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z - {0xFF3B, 0xFF3B, prF}, // Ps FULLWIDTH LEFT SQUARE BRACKET - {0xFF3C, 0xFF3C, prF}, // Po FULLWIDTH REVERSE SOLIDUS - {0xFF3D, 0xFF3D, prF}, // Pe FULLWIDTH RIGHT SQUARE BRACKET - {0xFF3E, 0xFF3E, prF}, // Sk FULLWIDTH CIRCUMFLEX ACCENT - {0xFF3F, 0xFF3F, prF}, // Pc FULLWIDTH LOW LINE - {0xFF40, 0xFF40, prF}, // Sk FULLWIDTH GRAVE ACCENT - {0xFF41, 0xFF5A, prF}, // Ll [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z - {0xFF5B, 0xFF5B, prF}, // Ps FULLWIDTH LEFT CURLY BRACKET - {0xFF5C, 0xFF5C, prF}, // Sm FULLWIDTH VERTICAL LINE - {0xFF5D, 0xFF5D, prF}, // Pe FULLWIDTH RIGHT CURLY BRACKET - {0xFF5E, 0xFF5E, prF}, // Sm FULLWIDTH TILDE - {0xFF5F, 0xFF5F, prF}, // Ps FULLWIDTH LEFT WHITE PARENTHESIS - {0xFF60, 0xFF60, prF}, // Pe FULLWIDTH RIGHT WHITE PARENTHESIS - {0xFF61, 0xFF61, prH}, // Po HALFWIDTH IDEOGRAPHIC FULL STOP - {0xFF62, 0xFF62, prH}, // Ps HALFWIDTH LEFT CORNER BRACKET - {0xFF63, 0xFF63, prH}, // Pe HALFWIDTH RIGHT CORNER BRACKET - {0xFF64, 0xFF65, prH}, // Po [2] HALFWIDTH IDEOGRAPHIC COMMA..HALFWIDTH KATAKANA MIDDLE DOT - {0xFF66, 0xFF6F, prH}, // Lo [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU - {0xFF70, 0xFF70, prH}, // Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK - {0xFF71, 0xFF9D, prH}, // Lo [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N - {0xFF9E, 0xFF9F, prH}, // Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK - {0xFFA0, 0xFFBE, prH}, // Lo [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH - {0xFFC2, 0xFFC7, prH}, // Lo [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E - {0xFFCA, 0xFFCF, prH}, // Lo [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE - {0xFFD2, 0xFFD7, prH}, // Lo [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU - {0xFFDA, 0xFFDC, prH}, // Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I - {0xFFE0, 0xFFE1, prF}, // Sc [2] FULLWIDTH CENT SIGN..FULLWIDTH POUND SIGN - {0xFFE2, 0xFFE2, prF}, // Sm FULLWIDTH NOT SIGN - {0xFFE3, 0xFFE3, prF}, // Sk FULLWIDTH MACRON - {0xFFE4, 0xFFE4, prF}, // So FULLWIDTH BROKEN BAR - {0xFFE5, 0xFFE6, prF}, // Sc [2] FULLWIDTH YEN SIGN..FULLWIDTH WON SIGN - {0xFFE8, 0xFFE8, prH}, // So HALFWIDTH FORMS LIGHT VERTICAL - {0xFFE9, 0xFFEC, prH}, // Sm [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW - {0xFFED, 0xFFEE, prH}, // So [2] HALFWIDTH BLACK SQUARE..HALFWIDTH WHITE CIRCLE - {0xFFF9, 0xFFFB, prN}, // Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR - {0xFFFC, 0xFFFC, prN}, // So OBJECT REPLACEMENT CHARACTER - {0xFFFD, 0xFFFD, prA}, // So REPLACEMENT CHARACTER - {0x10000, 0x1000B, prN}, // Lo [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE - {0x1000D, 0x10026, prN}, // Lo [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO - {0x10028, 0x1003A, prN}, // Lo [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO - {0x1003C, 0x1003D, prN}, // Lo [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE - {0x1003F, 0x1004D, prN}, // Lo [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO - {0x10050, 0x1005D, prN}, // Lo [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089 - {0x10080, 0x100FA, prN}, // Lo [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305 - {0x10100, 0x10102, prN}, // Po [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK - {0x10107, 0x10133, prN}, // No [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND - {0x10137, 0x1013F, prN}, // So [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT - {0x10140, 0x10174, prN}, // Nl [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS - {0x10175, 0x10178, prN}, // No [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN - {0x10179, 0x10189, prN}, // So [17] GREEK YEAR SIGN..GREEK TRYBLION BASE SIGN - {0x1018A, 0x1018B, prN}, // No [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN - {0x1018C, 0x1018E, prN}, // So [3] GREEK SINUSOID SIGN..NOMISMA SIGN - {0x10190, 0x1019C, prN}, // So [13] ROMAN SEXTANS SIGN..ASCIA SYMBOL - {0x101A0, 0x101A0, prN}, // So GREEK SYMBOL TAU RHO - {0x101D0, 0x101FC, prN}, // So [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND - {0x101FD, 0x101FD, prN}, // Mn PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE - {0x10280, 0x1029C, prN}, // Lo [29] LYCIAN LETTER A..LYCIAN LETTER X - {0x102A0, 0x102D0, prN}, // Lo [49] CARIAN LETTER A..CARIAN LETTER UUU3 - {0x102E0, 0x102E0, prN}, // Mn COPTIC EPACT THOUSANDS MARK - {0x102E1, 0x102FB, prN}, // No [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED - {0x10300, 0x1031F, prN}, // Lo [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS - {0x10320, 0x10323, prN}, // No [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY - {0x1032D, 0x1032F, prN}, // Lo [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE - {0x10330, 0x10340, prN}, // Lo [17] GOTHIC LETTER AHSA..GOTHIC LETTER PAIRTHRA - {0x10341, 0x10341, prN}, // Nl GOTHIC LETTER NINETY - {0x10342, 0x10349, prN}, // Lo [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL - {0x1034A, 0x1034A, prN}, // Nl GOTHIC LETTER NINE HUNDRED - {0x10350, 0x10375, prN}, // Lo [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA - {0x10376, 0x1037A, prN}, // Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII - {0x10380, 0x1039D, prN}, // Lo [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU - {0x1039F, 0x1039F, prN}, // Po UGARITIC WORD DIVIDER - {0x103A0, 0x103C3, prN}, // Lo [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA - {0x103C8, 0x103CF, prN}, // Lo [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH - {0x103D0, 0x103D0, prN}, // Po OLD PERSIAN WORD DIVIDER - {0x103D1, 0x103D5, prN}, // Nl [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED - {0x10400, 0x1044F, prN}, // L& [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW - {0x10450, 0x1047F, prN}, // Lo [48] SHAVIAN LETTER PEEP..SHAVIAN LETTER YEW - {0x10480, 0x1049D, prN}, // Lo [30] OSMANYA LETTER ALEF..OSMANYA LETTER OO - {0x104A0, 0x104A9, prN}, // Nd [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE - {0x104B0, 0x104D3, prN}, // Lu [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA - {0x104D8, 0x104FB, prN}, // Ll [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA - {0x10500, 0x10527, prN}, // Lo [40] ELBASAN LETTER A..ELBASAN LETTER KHE - {0x10530, 0x10563, prN}, // Lo [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW - {0x1056F, 0x1056F, prN}, // Po CAUCASIAN ALBANIAN CITATION MARK - {0x10570, 0x1057A, prN}, // Lu [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA - {0x1057C, 0x1058A, prN}, // Lu [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE - {0x1058C, 0x10592, prN}, // Lu [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE - {0x10594, 0x10595, prN}, // Lu [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE - {0x10597, 0x105A1, prN}, // Ll [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA - {0x105A3, 0x105B1, prN}, // Ll [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE - {0x105B3, 0x105B9, prN}, // Ll [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE - {0x105BB, 0x105BC, prN}, // Ll [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE - {0x10600, 0x10736, prN}, // Lo [311] LINEAR A SIGN AB001..LINEAR A SIGN A664 - {0x10740, 0x10755, prN}, // Lo [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE - {0x10760, 0x10767, prN}, // Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 - {0x10780, 0x10785, prN}, // Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK - {0x10787, 0x107B0, prN}, // Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK - {0x107B2, 0x107BA, prN}, // Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL - {0x10800, 0x10805, prN}, // Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA - {0x10808, 0x10808, prN}, // Lo CYPRIOT SYLLABLE JO - {0x1080A, 0x10835, prN}, // Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO - {0x10837, 0x10838, prN}, // Lo [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE - {0x1083C, 0x1083C, prN}, // Lo CYPRIOT SYLLABLE ZA - {0x1083F, 0x1083F, prN}, // Lo CYPRIOT SYLLABLE ZO - {0x10840, 0x10855, prN}, // Lo [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW - {0x10857, 0x10857, prN}, // Po IMPERIAL ARAMAIC SECTION SIGN - {0x10858, 0x1085F, prN}, // No [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND - {0x10860, 0x10876, prN}, // Lo [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW - {0x10877, 0x10878, prN}, // So [2] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE RIGHT-POINTING FLEURON - {0x10879, 0x1087F, prN}, // No [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY - {0x10880, 0x1089E, prN}, // Lo [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW - {0x108A7, 0x108AF, prN}, // No [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED - {0x108E0, 0x108F2, prN}, // Lo [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH - {0x108F4, 0x108F5, prN}, // Lo [2] HATRAN LETTER SHIN..HATRAN LETTER TAW - {0x108FB, 0x108FF, prN}, // No [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED - {0x10900, 0x10915, prN}, // Lo [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU - {0x10916, 0x1091B, prN}, // No [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE - {0x1091F, 0x1091F, prN}, // Po PHOENICIAN WORD SEPARATOR - {0x10920, 0x10939, prN}, // Lo [26] LYDIAN LETTER A..LYDIAN LETTER C - {0x1093F, 0x1093F, prN}, // Po LYDIAN TRIANGULAR MARK - {0x10980, 0x1099F, prN}, // Lo [32] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC HIEROGLYPHIC SYMBOL VIDJ-2 - {0x109A0, 0x109B7, prN}, // Lo [24] MEROITIC CURSIVE LETTER A..MEROITIC CURSIVE LETTER DA - {0x109BC, 0x109BD, prN}, // No [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF - {0x109BE, 0x109BF, prN}, // Lo [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN - {0x109C0, 0x109CF, prN}, // No [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY - {0x109D2, 0x109FF, prN}, // No [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS - {0x10A00, 0x10A00, prN}, // Lo KHAROSHTHI LETTER A - {0x10A01, 0x10A03, prN}, // Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R - {0x10A05, 0x10A06, prN}, // Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O - {0x10A0C, 0x10A0F, prN}, // Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA - {0x10A10, 0x10A13, prN}, // Lo [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA - {0x10A15, 0x10A17, prN}, // Lo [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA - {0x10A19, 0x10A35, prN}, // Lo [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA - {0x10A38, 0x10A3A, prN}, // Mn [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW - {0x10A3F, 0x10A3F, prN}, // Mn KHAROSHTHI VIRAMA - {0x10A40, 0x10A48, prN}, // No [9] KHAROSHTHI DIGIT ONE..KHAROSHTHI FRACTION ONE HALF - {0x10A50, 0x10A58, prN}, // Po [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES - {0x10A60, 0x10A7C, prN}, // Lo [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH - {0x10A7D, 0x10A7E, prN}, // No [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY - {0x10A7F, 0x10A7F, prN}, // Po OLD SOUTH ARABIAN NUMERIC INDICATOR - {0x10A80, 0x10A9C, prN}, // Lo [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH - {0x10A9D, 0x10A9F, prN}, // No [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY - {0x10AC0, 0x10AC7, prN}, // Lo [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW - {0x10AC8, 0x10AC8, prN}, // So MANICHAEAN SIGN UD - {0x10AC9, 0x10AE4, prN}, // Lo [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW - {0x10AE5, 0x10AE6, prN}, // Mn [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW - {0x10AEB, 0x10AEF, prN}, // No [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED - {0x10AF0, 0x10AF6, prN}, // Po [7] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION LINE FILLER - {0x10B00, 0x10B35, prN}, // Lo [54] AVESTAN LETTER A..AVESTAN LETTER HE - {0x10B39, 0x10B3F, prN}, // Po [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION - {0x10B40, 0x10B55, prN}, // Lo [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW - {0x10B58, 0x10B5F, prN}, // No [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND - {0x10B60, 0x10B72, prN}, // Lo [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW - {0x10B78, 0x10B7F, prN}, // No [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND - {0x10B80, 0x10B91, prN}, // Lo [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW - {0x10B99, 0x10B9C, prN}, // Po [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT - {0x10BA9, 0x10BAF, prN}, // No [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED - {0x10C00, 0x10C48, prN}, // Lo [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH - {0x10C80, 0x10CB2, prN}, // Lu [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US - {0x10CC0, 0x10CF2, prN}, // Ll [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US - {0x10CFA, 0x10CFF, prN}, // No [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND - {0x10D00, 0x10D23, prN}, // Lo [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA - {0x10D24, 0x10D27, prN}, // Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI - {0x10D30, 0x10D39, prN}, // Nd [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE - {0x10E60, 0x10E7E, prN}, // No [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS - {0x10E80, 0x10EA9, prN}, // Lo [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET - {0x10EAB, 0x10EAC, prN}, // Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK - {0x10EAD, 0x10EAD, prN}, // Pd YEZIDI HYPHENATION MARK - {0x10EB0, 0x10EB1, prN}, // Lo [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE - {0x10EFD, 0x10EFF, prN}, // Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA - {0x10F00, 0x10F1C, prN}, // Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL - {0x10F1D, 0x10F26, prN}, // No [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF - {0x10F27, 0x10F27, prN}, // Lo OLD SOGDIAN LIGATURE AYIN-DALETH - {0x10F30, 0x10F45, prN}, // Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN - {0x10F46, 0x10F50, prN}, // Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW - {0x10F51, 0x10F54, prN}, // No [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED - {0x10F55, 0x10F59, prN}, // Po [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT - {0x10F70, 0x10F81, prN}, // Lo [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH - {0x10F82, 0x10F85, prN}, // Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW - {0x10F86, 0x10F89, prN}, // Po [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS - {0x10FB0, 0x10FC4, prN}, // Lo [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW - {0x10FC5, 0x10FCB, prN}, // No [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED - {0x10FE0, 0x10FF6, prN}, // Lo [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH - {0x11000, 0x11000, prN}, // Mc BRAHMI SIGN CANDRABINDU - {0x11001, 0x11001, prN}, // Mn BRAHMI SIGN ANUSVARA - {0x11002, 0x11002, prN}, // Mc BRAHMI SIGN VISARGA - {0x11003, 0x11037, prN}, // Lo [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA - {0x11038, 0x11046, prN}, // Mn [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA - {0x11047, 0x1104D, prN}, // Po [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS - {0x11052, 0x11065, prN}, // No [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND - {0x11066, 0x1106F, prN}, // Nd [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE - {0x11070, 0x11070, prN}, // Mn BRAHMI SIGN OLD TAMIL VIRAMA - {0x11071, 0x11072, prN}, // Lo [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O - {0x11073, 0x11074, prN}, // Mn [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O - {0x11075, 0x11075, prN}, // Lo BRAHMI LETTER OLD TAMIL LLA - {0x1107F, 0x1107F, prN}, // Mn BRAHMI NUMBER JOINER - {0x11080, 0x11081, prN}, // Mn [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA - {0x11082, 0x11082, prN}, // Mc KAITHI SIGN VISARGA - {0x11083, 0x110AF, prN}, // Lo [45] KAITHI LETTER A..KAITHI LETTER HA - {0x110B0, 0x110B2, prN}, // Mc [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II - {0x110B3, 0x110B6, prN}, // Mn [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI - {0x110B7, 0x110B8, prN}, // Mc [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU - {0x110B9, 0x110BA, prN}, // Mn [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA - {0x110BB, 0x110BC, prN}, // Po [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN - {0x110BD, 0x110BD, prN}, // Cf KAITHI NUMBER SIGN - {0x110BE, 0x110C1, prN}, // Po [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA - {0x110C2, 0x110C2, prN}, // Mn KAITHI VOWEL SIGN VOCALIC R - {0x110CD, 0x110CD, prN}, // Cf KAITHI NUMBER SIGN ABOVE - {0x110D0, 0x110E8, prN}, // Lo [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE - {0x110F0, 0x110F9, prN}, // Nd [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE - {0x11100, 0x11102, prN}, // Mn [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA - {0x11103, 0x11126, prN}, // Lo [36] CHAKMA LETTER AA..CHAKMA LETTER HAA - {0x11127, 0x1112B, prN}, // Mn [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU - {0x1112C, 0x1112C, prN}, // Mc CHAKMA VOWEL SIGN E - {0x1112D, 0x11134, prN}, // Mn [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA - {0x11136, 0x1113F, prN}, // Nd [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE - {0x11140, 0x11143, prN}, // Po [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK - {0x11144, 0x11144, prN}, // Lo CHAKMA LETTER LHAA - {0x11145, 0x11146, prN}, // Mc [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI - {0x11147, 0x11147, prN}, // Lo CHAKMA LETTER VAA - {0x11150, 0x11172, prN}, // Lo [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA - {0x11173, 0x11173, prN}, // Mn MAHAJANI SIGN NUKTA - {0x11174, 0x11175, prN}, // Po [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK - {0x11176, 0x11176, prN}, // Lo MAHAJANI LIGATURE SHRI - {0x11180, 0x11181, prN}, // Mn [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA - {0x11182, 0x11182, prN}, // Mc SHARADA SIGN VISARGA - {0x11183, 0x111B2, prN}, // Lo [48] SHARADA LETTER A..SHARADA LETTER HA - {0x111B3, 0x111B5, prN}, // Mc [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II - {0x111B6, 0x111BE, prN}, // Mn [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O - {0x111BF, 0x111C0, prN}, // Mc [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA - {0x111C1, 0x111C4, prN}, // Lo [4] SHARADA SIGN AVAGRAHA..SHARADA OM - {0x111C5, 0x111C8, prN}, // Po [4] SHARADA DANDA..SHARADA SEPARATOR - {0x111C9, 0x111CC, prN}, // Mn [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK - {0x111CD, 0x111CD, prN}, // Po SHARADA SUTRA MARK - {0x111CE, 0x111CE, prN}, // Mc SHARADA VOWEL SIGN PRISHTHAMATRA E - {0x111CF, 0x111CF, prN}, // Mn SHARADA SIGN INVERTED CANDRABINDU - {0x111D0, 0x111D9, prN}, // Nd [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE - {0x111DA, 0x111DA, prN}, // Lo SHARADA EKAM - {0x111DB, 0x111DB, prN}, // Po SHARADA SIGN SIDDHAM - {0x111DC, 0x111DC, prN}, // Lo SHARADA HEADSTROKE - {0x111DD, 0x111DF, prN}, // Po [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2 - {0x111E1, 0x111F4, prN}, // No [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND - {0x11200, 0x11211, prN}, // Lo [18] KHOJKI LETTER A..KHOJKI LETTER JJA - {0x11213, 0x1122B, prN}, // Lo [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA - {0x1122C, 0x1122E, prN}, // Mc [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II - {0x1122F, 0x11231, prN}, // Mn [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI - {0x11232, 0x11233, prN}, // Mc [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU - {0x11234, 0x11234, prN}, // Mn KHOJKI SIGN ANUSVARA - {0x11235, 0x11235, prN}, // Mc KHOJKI SIGN VIRAMA - {0x11236, 0x11237, prN}, // Mn [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA - {0x11238, 0x1123D, prN}, // Po [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN - {0x1123E, 0x1123E, prN}, // Mn KHOJKI SIGN SUKUN - {0x1123F, 0x11240, prN}, // Lo [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I - {0x11241, 0x11241, prN}, // Mn KHOJKI VOWEL SIGN VOCALIC R - {0x11280, 0x11286, prN}, // Lo [7] MULTANI LETTER A..MULTANI LETTER GA - {0x11288, 0x11288, prN}, // Lo MULTANI LETTER GHA - {0x1128A, 0x1128D, prN}, // Lo [4] MULTANI LETTER CA..MULTANI LETTER JJA - {0x1128F, 0x1129D, prN}, // Lo [15] MULTANI LETTER NYA..MULTANI LETTER BA - {0x1129F, 0x112A8, prN}, // Lo [10] MULTANI LETTER BHA..MULTANI LETTER RHA - {0x112A9, 0x112A9, prN}, // Po MULTANI SECTION MARK - {0x112B0, 0x112DE, prN}, // Lo [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA - {0x112DF, 0x112DF, prN}, // Mn KHUDAWADI SIGN ANUSVARA - {0x112E0, 0x112E2, prN}, // Mc [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II - {0x112E3, 0x112EA, prN}, // Mn [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA - {0x112F0, 0x112F9, prN}, // Nd [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE - {0x11300, 0x11301, prN}, // Mn [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU - {0x11302, 0x11303, prN}, // Mc [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA - {0x11305, 0x1130C, prN}, // Lo [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L - {0x1130F, 0x11310, prN}, // Lo [2] GRANTHA LETTER EE..GRANTHA LETTER AI - {0x11313, 0x11328, prN}, // Lo [22] GRANTHA LETTER OO..GRANTHA LETTER NA - {0x1132A, 0x11330, prN}, // Lo [7] GRANTHA LETTER PA..GRANTHA LETTER RA - {0x11332, 0x11333, prN}, // Lo [2] GRANTHA LETTER LA..GRANTHA LETTER LLA - {0x11335, 0x11339, prN}, // Lo [5] GRANTHA LETTER VA..GRANTHA LETTER HA - {0x1133B, 0x1133C, prN}, // Mn [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA - {0x1133D, 0x1133D, prN}, // Lo GRANTHA SIGN AVAGRAHA - {0x1133E, 0x1133F, prN}, // Mc [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I - {0x11340, 0x11340, prN}, // Mn GRANTHA VOWEL SIGN II - {0x11341, 0x11344, prN}, // Mc [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR - {0x11347, 0x11348, prN}, // Mc [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI - {0x1134B, 0x1134D, prN}, // Mc [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA - {0x11350, 0x11350, prN}, // Lo GRANTHA OM - {0x11357, 0x11357, prN}, // Mc GRANTHA AU LENGTH MARK - {0x1135D, 0x11361, prN}, // Lo [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL - {0x11362, 0x11363, prN}, // Mc [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL - {0x11366, 0x1136C, prN}, // Mn [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX - {0x11370, 0x11374, prN}, // Mn [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA - {0x11400, 0x11434, prN}, // Lo [53] NEWA LETTER A..NEWA LETTER HA - {0x11435, 0x11437, prN}, // Mc [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II - {0x11438, 0x1143F, prN}, // Mn [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI - {0x11440, 0x11441, prN}, // Mc [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU - {0x11442, 0x11444, prN}, // Mn [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA - {0x11445, 0x11445, prN}, // Mc NEWA SIGN VISARGA - {0x11446, 0x11446, prN}, // Mn NEWA SIGN NUKTA - {0x11447, 0x1144A, prN}, // Lo [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI - {0x1144B, 0x1144F, prN}, // Po [5] NEWA DANDA..NEWA ABBREVIATION SIGN - {0x11450, 0x11459, prN}, // Nd [10] NEWA DIGIT ZERO..NEWA DIGIT NINE - {0x1145A, 0x1145B, prN}, // Po [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK - {0x1145D, 0x1145D, prN}, // Po NEWA INSERTION SIGN - {0x1145E, 0x1145E, prN}, // Mn NEWA SANDHI MARK - {0x1145F, 0x11461, prN}, // Lo [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA - {0x11480, 0x114AF, prN}, // Lo [48] TIRHUTA ANJI..TIRHUTA LETTER HA - {0x114B0, 0x114B2, prN}, // Mc [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II - {0x114B3, 0x114B8, prN}, // Mn [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL - {0x114B9, 0x114B9, prN}, // Mc TIRHUTA VOWEL SIGN E - {0x114BA, 0x114BA, prN}, // Mn TIRHUTA VOWEL SIGN SHORT E - {0x114BB, 0x114BE, prN}, // Mc [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU - {0x114BF, 0x114C0, prN}, // Mn [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA - {0x114C1, 0x114C1, prN}, // Mc TIRHUTA SIGN VISARGA - {0x114C2, 0x114C3, prN}, // Mn [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA - {0x114C4, 0x114C5, prN}, // Lo [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG - {0x114C6, 0x114C6, prN}, // Po TIRHUTA ABBREVIATION SIGN - {0x114C7, 0x114C7, prN}, // Lo TIRHUTA OM - {0x114D0, 0x114D9, prN}, // Nd [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE - {0x11580, 0x115AE, prN}, // Lo [47] SIDDHAM LETTER A..SIDDHAM LETTER HA - {0x115AF, 0x115B1, prN}, // Mc [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II - {0x115B2, 0x115B5, prN}, // Mn [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR - {0x115B8, 0x115BB, prN}, // Mc [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU - {0x115BC, 0x115BD, prN}, // Mn [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA - {0x115BE, 0x115BE, prN}, // Mc SIDDHAM SIGN VISARGA - {0x115BF, 0x115C0, prN}, // Mn [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA - {0x115C1, 0x115D7, prN}, // Po [23] SIDDHAM SIGN SIDDHAM..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES - {0x115D8, 0x115DB, prN}, // Lo [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U - {0x115DC, 0x115DD, prN}, // Mn [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU - {0x11600, 0x1162F, prN}, // Lo [48] MODI LETTER A..MODI LETTER LLA - {0x11630, 0x11632, prN}, // Mc [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II - {0x11633, 0x1163A, prN}, // Mn [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI - {0x1163B, 0x1163C, prN}, // Mc [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU - {0x1163D, 0x1163D, prN}, // Mn MODI SIGN ANUSVARA - {0x1163E, 0x1163E, prN}, // Mc MODI SIGN VISARGA - {0x1163F, 0x11640, prN}, // Mn [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA - {0x11641, 0x11643, prN}, // Po [3] MODI DANDA..MODI ABBREVIATION SIGN - {0x11644, 0x11644, prN}, // Lo MODI SIGN HUVA - {0x11650, 0x11659, prN}, // Nd [10] MODI DIGIT ZERO..MODI DIGIT NINE - {0x11660, 0x1166C, prN}, // Po [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT - {0x11680, 0x116AA, prN}, // Lo [43] TAKRI LETTER A..TAKRI LETTER RRA - {0x116AB, 0x116AB, prN}, // Mn TAKRI SIGN ANUSVARA - {0x116AC, 0x116AC, prN}, // Mc TAKRI SIGN VISARGA - {0x116AD, 0x116AD, prN}, // Mn TAKRI VOWEL SIGN AA - {0x116AE, 0x116AF, prN}, // Mc [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II - {0x116B0, 0x116B5, prN}, // Mn [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU - {0x116B6, 0x116B6, prN}, // Mc TAKRI SIGN VIRAMA - {0x116B7, 0x116B7, prN}, // Mn TAKRI SIGN NUKTA - {0x116B8, 0x116B8, prN}, // Lo TAKRI LETTER ARCHAIC KHA - {0x116B9, 0x116B9, prN}, // Po TAKRI ABBREVIATION SIGN - {0x116C0, 0x116C9, prN}, // Nd [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE - {0x11700, 0x1171A, prN}, // Lo [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA - {0x1171D, 0x1171F, prN}, // Mn [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA - {0x11720, 0x11721, prN}, // Mc [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA - {0x11722, 0x11725, prN}, // Mn [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU - {0x11726, 0x11726, prN}, // Mc AHOM VOWEL SIGN E - {0x11727, 0x1172B, prN}, // Mn [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER - {0x11730, 0x11739, prN}, // Nd [10] AHOM DIGIT ZERO..AHOM DIGIT NINE - {0x1173A, 0x1173B, prN}, // No [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY - {0x1173C, 0x1173E, prN}, // Po [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI - {0x1173F, 0x1173F, prN}, // So AHOM SYMBOL VI - {0x11740, 0x11746, prN}, // Lo [7] AHOM LETTER CA..AHOM LETTER LLA - {0x11800, 0x1182B, prN}, // Lo [44] DOGRA LETTER A..DOGRA LETTER RRA - {0x1182C, 0x1182E, prN}, // Mc [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II - {0x1182F, 0x11837, prN}, // Mn [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA - {0x11838, 0x11838, prN}, // Mc DOGRA SIGN VISARGA - {0x11839, 0x1183A, prN}, // Mn [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA - {0x1183B, 0x1183B, prN}, // Po DOGRA ABBREVIATION SIGN - {0x118A0, 0x118DF, prN}, // L& [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO - {0x118E0, 0x118E9, prN}, // Nd [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE - {0x118EA, 0x118F2, prN}, // No [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY - {0x118FF, 0x118FF, prN}, // Lo WARANG CITI OM - {0x11900, 0x11906, prN}, // Lo [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E - {0x11909, 0x11909, prN}, // Lo DIVES AKURU LETTER O - {0x1190C, 0x11913, prN}, // Lo [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA - {0x11915, 0x11916, prN}, // Lo [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA - {0x11918, 0x1192F, prN}, // Lo [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA - {0x11930, 0x11935, prN}, // Mc [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E - {0x11937, 0x11938, prN}, // Mc [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O - {0x1193B, 0x1193C, prN}, // Mn [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU - {0x1193D, 0x1193D, prN}, // Mc DIVES AKURU SIGN HALANTA - {0x1193E, 0x1193E, prN}, // Mn DIVES AKURU VIRAMA - {0x1193F, 0x1193F, prN}, // Lo DIVES AKURU PREFIXED NASAL SIGN - {0x11940, 0x11940, prN}, // Mc DIVES AKURU MEDIAL YA - {0x11941, 0x11941, prN}, // Lo DIVES AKURU INITIAL RA - {0x11942, 0x11942, prN}, // Mc DIVES AKURU MEDIAL RA - {0x11943, 0x11943, prN}, // Mn DIVES AKURU SIGN NUKTA - {0x11944, 0x11946, prN}, // Po [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK - {0x11950, 0x11959, prN}, // Nd [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE - {0x119A0, 0x119A7, prN}, // Lo [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR - {0x119AA, 0x119D0, prN}, // Lo [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA - {0x119D1, 0x119D3, prN}, // Mc [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II - {0x119D4, 0x119D7, prN}, // Mn [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR - {0x119DA, 0x119DB, prN}, // Mn [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI - {0x119DC, 0x119DF, prN}, // Mc [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA - {0x119E0, 0x119E0, prN}, // Mn NANDINAGARI SIGN VIRAMA - {0x119E1, 0x119E1, prN}, // Lo NANDINAGARI SIGN AVAGRAHA - {0x119E2, 0x119E2, prN}, // Po NANDINAGARI SIGN SIDDHAM - {0x119E3, 0x119E3, prN}, // Lo NANDINAGARI HEADSTROKE - {0x119E4, 0x119E4, prN}, // Mc NANDINAGARI VOWEL SIGN PRISHTHAMATRA E - {0x11A00, 0x11A00, prN}, // Lo ZANABAZAR SQUARE LETTER A - {0x11A01, 0x11A0A, prN}, // Mn [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK - {0x11A0B, 0x11A32, prN}, // Lo [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA - {0x11A33, 0x11A38, prN}, // Mn [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA - {0x11A39, 0x11A39, prN}, // Mc ZANABAZAR SQUARE SIGN VISARGA - {0x11A3A, 0x11A3A, prN}, // Lo ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA - {0x11A3B, 0x11A3E, prN}, // Mn [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA - {0x11A3F, 0x11A46, prN}, // Po [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK - {0x11A47, 0x11A47, prN}, // Mn ZANABAZAR SQUARE SUBJOINER - {0x11A50, 0x11A50, prN}, // Lo SOYOMBO LETTER A - {0x11A51, 0x11A56, prN}, // Mn [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE - {0x11A57, 0x11A58, prN}, // Mc [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU - {0x11A59, 0x11A5B, prN}, // Mn [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK - {0x11A5C, 0x11A89, prN}, // Lo [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA - {0x11A8A, 0x11A96, prN}, // Mn [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA - {0x11A97, 0x11A97, prN}, // Mc SOYOMBO SIGN VISARGA - {0x11A98, 0x11A99, prN}, // Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER - {0x11A9A, 0x11A9C, prN}, // Po [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD - {0x11A9D, 0x11A9D, prN}, // Lo SOYOMBO MARK PLUTA - {0x11A9E, 0x11AA2, prN}, // Po [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2 - {0x11AB0, 0x11ABF, prN}, // Lo [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA - {0x11AC0, 0x11AF8, prN}, // Lo [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL - {0x11B00, 0x11B09, prN}, // Po [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU - {0x11C00, 0x11C08, prN}, // Lo [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L - {0x11C0A, 0x11C2E, prN}, // Lo [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA - {0x11C2F, 0x11C2F, prN}, // Mc BHAIKSUKI VOWEL SIGN AA - {0x11C30, 0x11C36, prN}, // Mn [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L - {0x11C38, 0x11C3D, prN}, // Mn [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA - {0x11C3E, 0x11C3E, prN}, // Mc BHAIKSUKI SIGN VISARGA - {0x11C3F, 0x11C3F, prN}, // Mn BHAIKSUKI SIGN VIRAMA - {0x11C40, 0x11C40, prN}, // Lo BHAIKSUKI SIGN AVAGRAHA - {0x11C41, 0x11C45, prN}, // Po [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2 - {0x11C50, 0x11C59, prN}, // Nd [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE - {0x11C5A, 0x11C6C, prN}, // No [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK - {0x11C70, 0x11C71, prN}, // Po [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD - {0x11C72, 0x11C8F, prN}, // Lo [30] MARCHEN LETTER KA..MARCHEN LETTER A - {0x11C92, 0x11CA7, prN}, // Mn [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA - {0x11CA9, 0x11CA9, prN}, // Mc MARCHEN SUBJOINED LETTER YA - {0x11CAA, 0x11CB0, prN}, // Mn [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA - {0x11CB1, 0x11CB1, prN}, // Mc MARCHEN VOWEL SIGN I - {0x11CB2, 0x11CB3, prN}, // Mn [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E - {0x11CB4, 0x11CB4, prN}, // Mc MARCHEN VOWEL SIGN O - {0x11CB5, 0x11CB6, prN}, // Mn [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU - {0x11D00, 0x11D06, prN}, // Lo [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E - {0x11D08, 0x11D09, prN}, // Lo [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O - {0x11D0B, 0x11D30, prN}, // Lo [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA - {0x11D31, 0x11D36, prN}, // Mn [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R - {0x11D3A, 0x11D3A, prN}, // Mn MASARAM GONDI VOWEL SIGN E - {0x11D3C, 0x11D3D, prN}, // Mn [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O - {0x11D3F, 0x11D45, prN}, // Mn [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA - {0x11D46, 0x11D46, prN}, // Lo MASARAM GONDI REPHA - {0x11D47, 0x11D47, prN}, // Mn MASARAM GONDI RA-KARA - {0x11D50, 0x11D59, prN}, // Nd [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE - {0x11D60, 0x11D65, prN}, // Lo [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU - {0x11D67, 0x11D68, prN}, // Lo [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI - {0x11D6A, 0x11D89, prN}, // Lo [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA - {0x11D8A, 0x11D8E, prN}, // Mc [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU - {0x11D90, 0x11D91, prN}, // Mn [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI - {0x11D93, 0x11D94, prN}, // Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU - {0x11D95, 0x11D95, prN}, // Mn GUNJALA GONDI SIGN ANUSVARA - {0x11D96, 0x11D96, prN}, // Mc GUNJALA GONDI SIGN VISARGA - {0x11D97, 0x11D97, prN}, // Mn GUNJALA GONDI VIRAMA - {0x11D98, 0x11D98, prN}, // Lo GUNJALA GONDI OM - {0x11DA0, 0x11DA9, prN}, // Nd [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE - {0x11EE0, 0x11EF2, prN}, // Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA - {0x11EF3, 0x11EF4, prN}, // Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U - {0x11EF5, 0x11EF6, prN}, // Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O - {0x11EF7, 0x11EF8, prN}, // Po [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION - {0x11F00, 0x11F01, prN}, // Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA - {0x11F02, 0x11F02, prN}, // Lo KAWI SIGN REPHA - {0x11F03, 0x11F03, prN}, // Mc KAWI SIGN VISARGA - {0x11F04, 0x11F10, prN}, // Lo [13] KAWI LETTER A..KAWI LETTER O - {0x11F12, 0x11F33, prN}, // Lo [34] KAWI LETTER KA..KAWI LETTER JNYA - {0x11F34, 0x11F35, prN}, // Mc [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA - {0x11F36, 0x11F3A, prN}, // Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R - {0x11F3E, 0x11F3F, prN}, // Mc [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI - {0x11F40, 0x11F40, prN}, // Mn KAWI VOWEL SIGN EU - {0x11F41, 0x11F41, prN}, // Mc KAWI SIGN KILLER - {0x11F42, 0x11F42, prN}, // Mn KAWI CONJOINER - {0x11F43, 0x11F4F, prN}, // Po [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL - {0x11F50, 0x11F59, prN}, // Nd [10] KAWI DIGIT ZERO..KAWI DIGIT NINE - {0x11FB0, 0x11FB0, prN}, // Lo LISU LETTER YHA - {0x11FC0, 0x11FD4, prN}, // No [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH - {0x11FD5, 0x11FDC, prN}, // So [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI - {0x11FDD, 0x11FE0, prN}, // Sc [4] TAMIL SIGN KAACU..TAMIL SIGN VARAAKAN - {0x11FE1, 0x11FF1, prN}, // So [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA - {0x11FFF, 0x11FFF, prN}, // Po TAMIL PUNCTUATION END OF TEXT - {0x12000, 0x12399, prN}, // Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U - {0x12400, 0x1246E, prN}, // Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM - {0x12470, 0x12474, prN}, // Po [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON - {0x12480, 0x12543, prN}, // Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU - {0x12F90, 0x12FF0, prN}, // Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 - {0x12FF1, 0x12FF2, prN}, // Po [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302 - {0x13000, 0x1342F, prN}, // Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D - {0x13430, 0x1343F, prN}, // Cf [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE - {0x13440, 0x13440, prN}, // Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY - {0x13441, 0x13446, prN}, // Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN - {0x13447, 0x13455, prN}, // Mn [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED - {0x14400, 0x14646, prN}, // Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530 - {0x16800, 0x16A38, prN}, // Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ - {0x16A40, 0x16A5E, prN}, // Lo [31] MRO LETTER TA..MRO LETTER TEK - {0x16A60, 0x16A69, prN}, // Nd [10] MRO DIGIT ZERO..MRO DIGIT NINE - {0x16A6E, 0x16A6F, prN}, // Po [2] MRO DANDA..MRO DOUBLE DANDA - {0x16A70, 0x16ABE, prN}, // Lo [79] TANGSA LETTER OZ..TANGSA LETTER ZA - {0x16AC0, 0x16AC9, prN}, // Nd [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE - {0x16AD0, 0x16AED, prN}, // Lo [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I - {0x16AF0, 0x16AF4, prN}, // Mn [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE - {0x16AF5, 0x16AF5, prN}, // Po BASSA VAH FULL STOP - {0x16B00, 0x16B2F, prN}, // Lo [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU - {0x16B30, 0x16B36, prN}, // Mn [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM - {0x16B37, 0x16B3B, prN}, // Po [5] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS FEEM - {0x16B3C, 0x16B3F, prN}, // So [4] PAHAWH HMONG SIGN XYEEM NTXIV..PAHAWH HMONG SIGN XYEEM FAIB - {0x16B40, 0x16B43, prN}, // Lm [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM - {0x16B44, 0x16B44, prN}, // Po PAHAWH HMONG SIGN XAUS - {0x16B45, 0x16B45, prN}, // So PAHAWH HMONG SIGN CIM TSOV ROG - {0x16B50, 0x16B59, prN}, // Nd [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE - {0x16B5B, 0x16B61, prN}, // No [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS - {0x16B63, 0x16B77, prN}, // Lo [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS - {0x16B7D, 0x16B8F, prN}, // Lo [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ - {0x16E40, 0x16E7F, prN}, // L& [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y - {0x16E80, 0x16E96, prN}, // No [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM - {0x16E97, 0x16E9A, prN}, // Po [4] MEDEFAIDRIN COMMA..MEDEFAIDRIN EXCLAMATION OH - {0x16F00, 0x16F4A, prN}, // Lo [75] MIAO LETTER PA..MIAO LETTER RTE - {0x16F4F, 0x16F4F, prN}, // Mn MIAO SIGN CONSONANT MODIFIER BAR - {0x16F50, 0x16F50, prN}, // Lo MIAO LETTER NASALIZATION - {0x16F51, 0x16F87, prN}, // Mc [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI - {0x16F8F, 0x16F92, prN}, // Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW - {0x16F93, 0x16F9F, prN}, // Lm [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8 - {0x16FE0, 0x16FE1, prW}, // Lm [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK - {0x16FE2, 0x16FE2, prW}, // Po OLD CHINESE HOOK MARK - {0x16FE3, 0x16FE3, prW}, // Lm OLD CHINESE ITERATION MARK - {0x16FE4, 0x16FE4, prW}, // Mn KHITAN SMALL SCRIPT FILLER - {0x16FF0, 0x16FF1, prW}, // Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY - {0x17000, 0x187F7, prW}, // Lo [6136] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187F7 - {0x18800, 0x18AFF, prW}, // Lo [768] TANGUT COMPONENT-001..TANGUT COMPONENT-768 - {0x18B00, 0x18CD5, prW}, // Lo [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5 - {0x18D00, 0x18D08, prW}, // Lo [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08 - {0x1AFF0, 0x1AFF3, prW}, // Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 - {0x1AFF5, 0x1AFFB, prW}, // Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 - {0x1AFFD, 0x1AFFE, prW}, // Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 - {0x1B000, 0x1B0FF, prW}, // Lo [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2 - {0x1B100, 0x1B122, prW}, // Lo [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU - {0x1B132, 0x1B132, prW}, // Lo HIRAGANA LETTER SMALL KO - {0x1B150, 0x1B152, prW}, // Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO - {0x1B155, 0x1B155, prW}, // Lo KATAKANA LETTER SMALL KO - {0x1B164, 0x1B167, prW}, // Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N - {0x1B170, 0x1B2FB, prW}, // Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB - {0x1BC00, 0x1BC6A, prN}, // Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M - {0x1BC70, 0x1BC7C, prN}, // Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK - {0x1BC80, 0x1BC88, prN}, // Lo [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL - {0x1BC90, 0x1BC99, prN}, // Lo [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW - {0x1BC9C, 0x1BC9C, prN}, // So DUPLOYAN SIGN O WITH CROSS - {0x1BC9D, 0x1BC9E, prN}, // Mn [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK - {0x1BC9F, 0x1BC9F, prN}, // Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP - {0x1BCA0, 0x1BCA3, prN}, // Cf [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP - {0x1CF00, 0x1CF2D, prN}, // Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT - {0x1CF30, 0x1CF46, prN}, // Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG - {0x1CF50, 0x1CFC3, prN}, // So [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK - {0x1D000, 0x1D0F5, prN}, // So [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO - {0x1D100, 0x1D126, prN}, // So [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2 - {0x1D129, 0x1D164, prN}, // So [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE - {0x1D165, 0x1D166, prN}, // Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM - {0x1D167, 0x1D169, prN}, // Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 - {0x1D16A, 0x1D16C, prN}, // So [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3 - {0x1D16D, 0x1D172, prN}, // Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 - {0x1D173, 0x1D17A, prN}, // Cf [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE - {0x1D17B, 0x1D182, prN}, // Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE - {0x1D183, 0x1D184, prN}, // So [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN - {0x1D185, 0x1D18B, prN}, // Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE - {0x1D18C, 0x1D1A9, prN}, // So [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH - {0x1D1AA, 0x1D1AD, prN}, // Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO - {0x1D1AE, 0x1D1EA, prN}, // So [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON - {0x1D200, 0x1D241, prN}, // So [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54 - {0x1D242, 0x1D244, prN}, // Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME - {0x1D245, 0x1D245, prN}, // So GREEK MUSICAL LEIMMA - {0x1D2C0, 0x1D2D3, prN}, // No [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN - {0x1D2E0, 0x1D2F3, prN}, // No [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN - {0x1D300, 0x1D356, prN}, // So [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING - {0x1D360, 0x1D378, prN}, // No [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE - {0x1D400, 0x1D454, prN}, // L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G - {0x1D456, 0x1D49C, prN}, // L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A - {0x1D49E, 0x1D49F, prN}, // Lu [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D - {0x1D4A2, 0x1D4A2, prN}, // Lu MATHEMATICAL SCRIPT CAPITAL G - {0x1D4A5, 0x1D4A6, prN}, // Lu [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K - {0x1D4A9, 0x1D4AC, prN}, // Lu [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q - {0x1D4AE, 0x1D4B9, prN}, // L& [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D - {0x1D4BB, 0x1D4BB, prN}, // Ll MATHEMATICAL SCRIPT SMALL F - {0x1D4BD, 0x1D4C3, prN}, // Ll [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N - {0x1D4C5, 0x1D505, prN}, // L& [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B - {0x1D507, 0x1D50A, prN}, // Lu [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G - {0x1D50D, 0x1D514, prN}, // Lu [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q - {0x1D516, 0x1D51C, prN}, // Lu [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y - {0x1D51E, 0x1D539, prN}, // L& [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B - {0x1D53B, 0x1D53E, prN}, // Lu [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G - {0x1D540, 0x1D544, prN}, // Lu [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M - {0x1D546, 0x1D546, prN}, // Lu MATHEMATICAL DOUBLE-STRUCK CAPITAL O - {0x1D54A, 0x1D550, prN}, // Lu [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y - {0x1D552, 0x1D6A5, prN}, // L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J - {0x1D6A8, 0x1D6C0, prN}, // Lu [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA - {0x1D6C1, 0x1D6C1, prN}, // Sm MATHEMATICAL BOLD NABLA - {0x1D6C2, 0x1D6DA, prN}, // Ll [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA - {0x1D6DB, 0x1D6DB, prN}, // Sm MATHEMATICAL BOLD PARTIAL DIFFERENTIAL - {0x1D6DC, 0x1D6FA, prN}, // L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA - {0x1D6FB, 0x1D6FB, prN}, // Sm MATHEMATICAL ITALIC NABLA - {0x1D6FC, 0x1D714, prN}, // Ll [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA - {0x1D715, 0x1D715, prN}, // Sm MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL - {0x1D716, 0x1D734, prN}, // L& [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA - {0x1D735, 0x1D735, prN}, // Sm MATHEMATICAL BOLD ITALIC NABLA - {0x1D736, 0x1D74E, prN}, // Ll [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA - {0x1D74F, 0x1D74F, prN}, // Sm MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL - {0x1D750, 0x1D76E, prN}, // L& [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA - {0x1D76F, 0x1D76F, prN}, // Sm MATHEMATICAL SANS-SERIF BOLD NABLA - {0x1D770, 0x1D788, prN}, // Ll [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA - {0x1D789, 0x1D789, prN}, // Sm MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL - {0x1D78A, 0x1D7A8, prN}, // L& [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA - {0x1D7A9, 0x1D7A9, prN}, // Sm MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA - {0x1D7AA, 0x1D7C2, prN}, // Ll [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA - {0x1D7C3, 0x1D7C3, prN}, // Sm MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL - {0x1D7C4, 0x1D7CB, prN}, // L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA - {0x1D7CE, 0x1D7FF, prN}, // Nd [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE - {0x1D800, 0x1D9FF, prN}, // So [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD - {0x1DA00, 0x1DA36, prN}, // Mn [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN - {0x1DA37, 0x1DA3A, prN}, // So [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE - {0x1DA3B, 0x1DA6C, prN}, // Mn [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT - {0x1DA6D, 0x1DA74, prN}, // So [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING - {0x1DA75, 0x1DA75, prN}, // Mn SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS - {0x1DA76, 0x1DA83, prN}, // So [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH - {0x1DA84, 0x1DA84, prN}, // Mn SIGNWRITING LOCATION HEAD NECK - {0x1DA85, 0x1DA86, prN}, // So [2] SIGNWRITING LOCATION TORSO..SIGNWRITING LOCATION LIMBS DIGITS - {0x1DA87, 0x1DA8B, prN}, // Po [5] SIGNWRITING COMMA..SIGNWRITING PARENTHESIS - {0x1DA9B, 0x1DA9F, prN}, // Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 - {0x1DAA1, 0x1DAAF, prN}, // Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 - {0x1DF00, 0x1DF09, prN}, // Ll [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK - {0x1DF0A, 0x1DF0A, prN}, // Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK - {0x1DF0B, 0x1DF1E, prN}, // Ll [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL - {0x1DF25, 0x1DF2A, prN}, // Ll [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK - {0x1E000, 0x1E006, prN}, // Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE - {0x1E008, 0x1E018, prN}, // Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU - {0x1E01B, 0x1E021, prN}, // Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI - {0x1E023, 0x1E024, prN}, // Mn [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS - {0x1E026, 0x1E02A, prN}, // Mn [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA - {0x1E030, 0x1E06D, prN}, // Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE - {0x1E08F, 0x1E08F, prN}, // Mn COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I - {0x1E100, 0x1E12C, prN}, // Lo [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W - {0x1E130, 0x1E136, prN}, // Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D - {0x1E137, 0x1E13D, prN}, // Lm [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER - {0x1E140, 0x1E149, prN}, // Nd [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE - {0x1E14E, 0x1E14E, prN}, // Lo NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ - {0x1E14F, 0x1E14F, prN}, // So NYIAKENG PUACHUE HMONG CIRCLED CA - {0x1E290, 0x1E2AD, prN}, // Lo [30] TOTO LETTER PA..TOTO LETTER A - {0x1E2AE, 0x1E2AE, prN}, // Mn TOTO SIGN RISING TONE - {0x1E2C0, 0x1E2EB, prN}, // Lo [44] WANCHO LETTER AA..WANCHO LETTER YIH - {0x1E2EC, 0x1E2EF, prN}, // Mn [4] WANCHO TONE TUP..WANCHO TONE KOINI - {0x1E2F0, 0x1E2F9, prN}, // Nd [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE - {0x1E2FF, 0x1E2FF, prN}, // Sc WANCHO NGUN SIGN - {0x1E4D0, 0x1E4EA, prN}, // Lo [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL - {0x1E4EB, 0x1E4EB, prN}, // Lm NAG MUNDARI SIGN OJOD - {0x1E4EC, 0x1E4EF, prN}, // Mn [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH - {0x1E4F0, 0x1E4F9, prN}, // Nd [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE - {0x1E7E0, 0x1E7E6, prN}, // Lo [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO - {0x1E7E8, 0x1E7EB, prN}, // Lo [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE - {0x1E7ED, 0x1E7EE, prN}, // Lo [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE - {0x1E7F0, 0x1E7FE, prN}, // Lo [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE - {0x1E800, 0x1E8C4, prN}, // Lo [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON - {0x1E8C7, 0x1E8CF, prN}, // No [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE - {0x1E8D0, 0x1E8D6, prN}, // Mn [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS - {0x1E900, 0x1E943, prN}, // L& [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA - {0x1E944, 0x1E94A, prN}, // Mn [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA - {0x1E94B, 0x1E94B, prN}, // Lm ADLAM NASALIZATION MARK - {0x1E950, 0x1E959, prN}, // Nd [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE - {0x1E95E, 0x1E95F, prN}, // Po [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK - {0x1EC71, 0x1ECAB, prN}, // No [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE - {0x1ECAC, 0x1ECAC, prN}, // So INDIC SIYAQ PLACEHOLDER - {0x1ECAD, 0x1ECAF, prN}, // No [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS - {0x1ECB0, 0x1ECB0, prN}, // Sc INDIC SIYAQ RUPEE MARK - {0x1ECB1, 0x1ECB4, prN}, // No [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK - {0x1ED01, 0x1ED2D, prN}, // No [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND - {0x1ED2E, 0x1ED2E, prN}, // So OTTOMAN SIYAQ MARRATAN - {0x1ED2F, 0x1ED3D, prN}, // No [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH - {0x1EE00, 0x1EE03, prN}, // Lo [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL - {0x1EE05, 0x1EE1F, prN}, // Lo [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF - {0x1EE21, 0x1EE22, prN}, // Lo [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM - {0x1EE24, 0x1EE24, prN}, // Lo ARABIC MATHEMATICAL INITIAL HEH - {0x1EE27, 0x1EE27, prN}, // Lo ARABIC MATHEMATICAL INITIAL HAH - {0x1EE29, 0x1EE32, prN}, // Lo [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF - {0x1EE34, 0x1EE37, prN}, // Lo [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH - {0x1EE39, 0x1EE39, prN}, // Lo ARABIC MATHEMATICAL INITIAL DAD - {0x1EE3B, 0x1EE3B, prN}, // Lo ARABIC MATHEMATICAL INITIAL GHAIN - {0x1EE42, 0x1EE42, prN}, // Lo ARABIC MATHEMATICAL TAILED JEEM - {0x1EE47, 0x1EE47, prN}, // Lo ARABIC MATHEMATICAL TAILED HAH - {0x1EE49, 0x1EE49, prN}, // Lo ARABIC MATHEMATICAL TAILED YEH - {0x1EE4B, 0x1EE4B, prN}, // Lo ARABIC MATHEMATICAL TAILED LAM - {0x1EE4D, 0x1EE4F, prN}, // Lo [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN - {0x1EE51, 0x1EE52, prN}, // Lo [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF - {0x1EE54, 0x1EE54, prN}, // Lo ARABIC MATHEMATICAL TAILED SHEEN - {0x1EE57, 0x1EE57, prN}, // Lo ARABIC MATHEMATICAL TAILED KHAH - {0x1EE59, 0x1EE59, prN}, // Lo ARABIC MATHEMATICAL TAILED DAD - {0x1EE5B, 0x1EE5B, prN}, // Lo ARABIC MATHEMATICAL TAILED GHAIN - {0x1EE5D, 0x1EE5D, prN}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS NOON - {0x1EE5F, 0x1EE5F, prN}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS QAF - {0x1EE61, 0x1EE62, prN}, // Lo [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM - {0x1EE64, 0x1EE64, prN}, // Lo ARABIC MATHEMATICAL STRETCHED HEH - {0x1EE67, 0x1EE6A, prN}, // Lo [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF - {0x1EE6C, 0x1EE72, prN}, // Lo [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF - {0x1EE74, 0x1EE77, prN}, // Lo [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH - {0x1EE79, 0x1EE7C, prN}, // Lo [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH - {0x1EE7E, 0x1EE7E, prN}, // Lo ARABIC MATHEMATICAL STRETCHED DOTLESS FEH - {0x1EE80, 0x1EE89, prN}, // Lo [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH - {0x1EE8B, 0x1EE9B, prN}, // Lo [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN - {0x1EEA1, 0x1EEA3, prN}, // Lo [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL - {0x1EEA5, 0x1EEA9, prN}, // Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH - {0x1EEAB, 0x1EEBB, prN}, // Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN - {0x1EEF0, 0x1EEF1, prN}, // Sm [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL - {0x1F000, 0x1F003, prN}, // So [4] MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND - {0x1F004, 0x1F004, prW}, // So MAHJONG TILE RED DRAGON - {0x1F005, 0x1F02B, prN}, // So [39] MAHJONG TILE GREEN DRAGON..MAHJONG TILE BACK - {0x1F030, 0x1F093, prN}, // So [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06 - {0x1F0A0, 0x1F0AE, prN}, // So [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES - {0x1F0B1, 0x1F0BF, prN}, // So [15] PLAYING CARD ACE OF HEARTS..PLAYING CARD RED JOKER - {0x1F0C1, 0x1F0CE, prN}, // So [14] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD KING OF DIAMONDS - {0x1F0CF, 0x1F0CF, prW}, // So PLAYING CARD BLACK JOKER - {0x1F0D1, 0x1F0F5, prN}, // So [37] PLAYING CARD ACE OF CLUBS..PLAYING CARD TRUMP-21 - {0x1F100, 0x1F10A, prA}, // No [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA - {0x1F10B, 0x1F10C, prN}, // No [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO - {0x1F10D, 0x1F10F, prN}, // So [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH - {0x1F110, 0x1F12D, prA}, // So [30] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED CD - {0x1F12E, 0x1F12F, prN}, // So [2] CIRCLED WZ..COPYLEFT SYMBOL - {0x1F130, 0x1F169, prA}, // So [58] SQUARED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z - {0x1F16A, 0x1F16F, prN}, // So [6] RAISED MC SIGN..CIRCLED HUMAN FIGURE - {0x1F170, 0x1F18D, prA}, // So [30] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED SA - {0x1F18E, 0x1F18E, prW}, // So NEGATIVE SQUARED AB - {0x1F18F, 0x1F190, prA}, // So [2] NEGATIVE SQUARED WC..SQUARE DJ - {0x1F191, 0x1F19A, prW}, // So [10] SQUARED CL..SQUARED VS - {0x1F19B, 0x1F1AC, prA}, // So [18] SQUARED THREE D..SQUARED VOD - {0x1F1AD, 0x1F1AD, prN}, // So MASK WORK SYMBOL - {0x1F1E6, 0x1F1FF, prN}, // So [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z - {0x1F200, 0x1F202, prW}, // So [3] SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA - {0x1F210, 0x1F23B, prW}, // So [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D - {0x1F240, 0x1F248, prW}, // So [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557 - {0x1F250, 0x1F251, prW}, // So [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT - {0x1F260, 0x1F265, prW}, // So [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI - {0x1F300, 0x1F320, prW}, // So [33] CYCLONE..SHOOTING STAR - {0x1F321, 0x1F32C, prN}, // So [12] THERMOMETER..WIND BLOWING FACE - {0x1F32D, 0x1F335, prW}, // So [9] HOT DOG..CACTUS - {0x1F336, 0x1F336, prN}, // So HOT PEPPER - {0x1F337, 0x1F37C, prW}, // So [70] TULIP..BABY BOTTLE - {0x1F37D, 0x1F37D, prN}, // So FORK AND KNIFE WITH PLATE - {0x1F37E, 0x1F393, prW}, // So [22] BOTTLE WITH POPPING CORK..GRADUATION CAP - {0x1F394, 0x1F39F, prN}, // So [12] HEART WITH TIP ON THE LEFT..ADMISSION TICKETS - {0x1F3A0, 0x1F3CA, prW}, // So [43] CAROUSEL HORSE..SWIMMER - {0x1F3CB, 0x1F3CE, prN}, // So [4] WEIGHT LIFTER..RACING CAR - {0x1F3CF, 0x1F3D3, prW}, // So [5] CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL - {0x1F3D4, 0x1F3DF, prN}, // So [12] SNOW CAPPED MOUNTAIN..STADIUM - {0x1F3E0, 0x1F3F0, prW}, // So [17] HOUSE BUILDING..EUROPEAN CASTLE - {0x1F3F1, 0x1F3F3, prN}, // So [3] WHITE PENNANT..WAVING WHITE FLAG - {0x1F3F4, 0x1F3F4, prW}, // So WAVING BLACK FLAG - {0x1F3F5, 0x1F3F7, prN}, // So [3] ROSETTE..LABEL - {0x1F3F8, 0x1F3FA, prW}, // So [3] BADMINTON RACQUET AND SHUTTLECOCK..AMPHORA - {0x1F3FB, 0x1F3FF, prW}, // Sk [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6 - {0x1F400, 0x1F43E, prW}, // So [63] RAT..PAW PRINTS - {0x1F43F, 0x1F43F, prN}, // So CHIPMUNK - {0x1F440, 0x1F440, prW}, // So EYES - {0x1F441, 0x1F441, prN}, // So EYE - {0x1F442, 0x1F4FC, prW}, // So [187] EAR..VIDEOCASSETTE - {0x1F4FD, 0x1F4FE, prN}, // So [2] FILM PROJECTOR..PORTABLE STEREO - {0x1F4FF, 0x1F53D, prW}, // So [63] PRAYER BEADS..DOWN-POINTING SMALL RED TRIANGLE - {0x1F53E, 0x1F54A, prN}, // So [13] LOWER RIGHT SHADOWED WHITE CIRCLE..DOVE OF PEACE - {0x1F54B, 0x1F54E, prW}, // So [4] KAABA..MENORAH WITH NINE BRANCHES - {0x1F54F, 0x1F54F, prN}, // So BOWL OF HYGIEIA - {0x1F550, 0x1F567, prW}, // So [24] CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY - {0x1F568, 0x1F579, prN}, // So [18] RIGHT SPEAKER..JOYSTICK - {0x1F57A, 0x1F57A, prW}, // So MAN DANCING - {0x1F57B, 0x1F594, prN}, // So [26] LEFT HAND TELEPHONE RECEIVER..REVERSED VICTORY HAND - {0x1F595, 0x1F596, prW}, // So [2] REVERSED HAND WITH MIDDLE FINGER EXTENDED..RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS - {0x1F597, 0x1F5A3, prN}, // So [13] WHITE DOWN POINTING LEFT HAND INDEX..BLACK DOWN POINTING BACKHAND INDEX - {0x1F5A4, 0x1F5A4, prW}, // So BLACK HEART - {0x1F5A5, 0x1F5FA, prN}, // So [86] DESKTOP COMPUTER..WORLD MAP - {0x1F5FB, 0x1F5FF, prW}, // So [5] MOUNT FUJI..MOYAI - {0x1F600, 0x1F64F, prW}, // So [80] GRINNING FACE..PERSON WITH FOLDED HANDS - {0x1F650, 0x1F67F, prN}, // So [48] NORTH WEST POINTING LEAF..REVERSE CHECKER BOARD - {0x1F680, 0x1F6C5, prW}, // So [70] ROCKET..LEFT LUGGAGE - {0x1F6C6, 0x1F6CB, prN}, // So [6] TRIANGLE WITH ROUNDED CORNERS..COUCH AND LAMP - {0x1F6CC, 0x1F6CC, prW}, // So SLEEPING ACCOMMODATION - {0x1F6CD, 0x1F6CF, prN}, // So [3] SHOPPING BAGS..BED - {0x1F6D0, 0x1F6D2, prW}, // So [3] PLACE OF WORSHIP..SHOPPING TROLLEY - {0x1F6D3, 0x1F6D4, prN}, // So [2] STUPA..PAGODA - {0x1F6D5, 0x1F6D7, prW}, // So [3] HINDU TEMPLE..ELEVATOR - {0x1F6DC, 0x1F6DF, prW}, // So [4] WIRELESS..RING BUOY - {0x1F6E0, 0x1F6EA, prN}, // So [11] HAMMER AND WRENCH..NORTHEAST-POINTING AIRPLANE - {0x1F6EB, 0x1F6EC, prW}, // So [2] AIRPLANE DEPARTURE..AIRPLANE ARRIVING - {0x1F6F0, 0x1F6F3, prN}, // So [4] SATELLITE..PASSENGER SHIP - {0x1F6F4, 0x1F6FC, prW}, // So [9] SCOOTER..ROLLER SKATE - {0x1F700, 0x1F776, prN}, // So [119] ALCHEMICAL SYMBOL FOR QUINTESSENCE..LUNAR ECLIPSE - {0x1F77B, 0x1F77F, prN}, // So [5] HAUMEA..ORCUS - {0x1F780, 0x1F7D9, prN}, // So [90] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NINE POINTED WHITE STAR - {0x1F7E0, 0x1F7EB, prW}, // So [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE - {0x1F7F0, 0x1F7F0, prW}, // So HEAVY EQUALS SIGN - {0x1F800, 0x1F80B, prN}, // So [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD - {0x1F810, 0x1F847, prN}, // So [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW - {0x1F850, 0x1F859, prN}, // So [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW - {0x1F860, 0x1F887, prN}, // So [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW - {0x1F890, 0x1F8AD, prN}, // So [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS - {0x1F8B0, 0x1F8B1, prN}, // So [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST - {0x1F900, 0x1F90B, prN}, // So [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT - {0x1F90C, 0x1F93A, prW}, // So [47] PINCHED FINGERS..FENCER - {0x1F93B, 0x1F93B, prN}, // So MODERN PENTATHLON - {0x1F93C, 0x1F945, prW}, // So [10] WRESTLERS..GOAL NET - {0x1F946, 0x1F946, prN}, // So RIFLE - {0x1F947, 0x1F9FF, prW}, // So [185] FIRST PLACE MEDAL..NAZAR AMULET - {0x1FA00, 0x1FA53, prN}, // So [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP - {0x1FA60, 0x1FA6D, prN}, // So [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER - {0x1FA70, 0x1FA7C, prW}, // So [13] BALLET SHOES..CRUTCH - {0x1FA80, 0x1FA88, prW}, // So [9] YO-YO..FLUTE - {0x1FA90, 0x1FABD, prW}, // So [46] RINGED PLANET..WING - {0x1FABF, 0x1FAC5, prW}, // So [7] GOOSE..PERSON WITH CROWN - {0x1FACE, 0x1FADB, prW}, // So [14] MOOSE..PEA POD - {0x1FAE0, 0x1FAE8, prW}, // So [9] MELTING FACE..SHAKING FACE - {0x1FAF0, 0x1FAF8, prW}, // So [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND - {0x1FB00, 0x1FB92, prN}, // So [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK - {0x1FB94, 0x1FBCA, prN}, // So [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON - {0x1FBF0, 0x1FBF9, prN}, // Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE - {0x20000, 0x2A6DF, prW}, // Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF - {0x2A6E0, 0x2A6FF, prW}, // Cn [32] .. - {0x2A700, 0x2B739, prW}, // Lo [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739 - {0x2B73A, 0x2B73F, prW}, // Cn [6] .. - {0x2B740, 0x2B81D, prW}, // Lo [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D - {0x2B81E, 0x2B81F, prW}, // Cn [2] .. - {0x2B820, 0x2CEA1, prW}, // Lo [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1 - {0x2CEA2, 0x2CEAF, prW}, // Cn [14] .. - {0x2CEB0, 0x2EBE0, prW}, // Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 - {0x2EBE1, 0x2F7FF, prW}, // Cn [3103] .. - {0x2F800, 0x2FA1D, prW}, // Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D - {0x2FA1E, 0x2FA1F, prW}, // Cn [2] .. - {0x2FA20, 0x2FFFD, prW}, // Cn [1502] .. - {0x30000, 0x3134A, prW}, // Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A - {0x3134B, 0x3134F, prW}, // Cn [5] .. - {0x31350, 0x323AF, prW}, // Lo [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF - {0x323B0, 0x3FFFD, prW}, // Cn [56398] .. - {0xE0001, 0xE0001, prN}, // Cf LANGUAGE TAG - {0xE0020, 0xE007F, prN}, // Cf [96] TAG SPACE..CANCEL TAG - {0xE0100, 0xE01EF, prA}, // Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 - {0xF0000, 0xFFFFD, prA}, // Co [65534] .. - {0x100000, 0x10FFFD, prA}, // Co [65534] .. -} diff --git a/vendor/github.com/rivo/uniseg/emojipresentation.go b/vendor/github.com/rivo/uniseg/emojipresentation.go deleted file mode 100644 index 9b5f499..0000000 --- a/vendor/github.com/rivo/uniseg/emojipresentation.go +++ /dev/null @@ -1,295 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// emojiPresentation are taken from -// -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var emojiPresentation = [][3]int{ - {0x231A, 0x231B, prEmojiPresentation}, // E0.6 [2] (⌚..⌛) watch..hourglass done - {0x23E9, 0x23EC, prEmojiPresentation}, // E0.6 [4] (⏩..⏬) fast-forward button..fast down button - {0x23F0, 0x23F0, prEmojiPresentation}, // E0.6 [1] (⏰) alarm clock - {0x23F3, 0x23F3, prEmojiPresentation}, // E0.6 [1] (⏳) hourglass not done - {0x25FD, 0x25FE, prEmojiPresentation}, // E0.6 [2] (◽..◾) white medium-small square..black medium-small square - {0x2614, 0x2615, prEmojiPresentation}, // E0.6 [2] (☔..☕) umbrella with rain drops..hot beverage - {0x2648, 0x2653, prEmojiPresentation}, // E0.6 [12] (♈..♓) Aries..Pisces - {0x267F, 0x267F, prEmojiPresentation}, // E0.6 [1] (♿) wheelchair symbol - {0x2693, 0x2693, prEmojiPresentation}, // E0.6 [1] (⚓) anchor - {0x26A1, 0x26A1, prEmojiPresentation}, // E0.6 [1] (⚡) high voltage - {0x26AA, 0x26AB, prEmojiPresentation}, // E0.6 [2] (⚪..⚫) white circle..black circle - {0x26BD, 0x26BE, prEmojiPresentation}, // E0.6 [2] (⚽..⚾) soccer ball..baseball - {0x26C4, 0x26C5, prEmojiPresentation}, // E0.6 [2] (⛄..⛅) snowman without snow..sun behind cloud - {0x26CE, 0x26CE, prEmojiPresentation}, // E0.6 [1] (⛎) Ophiuchus - {0x26D4, 0x26D4, prEmojiPresentation}, // E0.6 [1] (⛔) no entry - {0x26EA, 0x26EA, prEmojiPresentation}, // E0.6 [1] (⛪) church - {0x26F2, 0x26F3, prEmojiPresentation}, // E0.6 [2] (⛲..⛳) fountain..flag in hole - {0x26F5, 0x26F5, prEmojiPresentation}, // E0.6 [1] (⛵) sailboat - {0x26FA, 0x26FA, prEmojiPresentation}, // E0.6 [1] (⛺) tent - {0x26FD, 0x26FD, prEmojiPresentation}, // E0.6 [1] (⛽) fuel pump - {0x2705, 0x2705, prEmojiPresentation}, // E0.6 [1] (✅) check mark button - {0x270A, 0x270B, prEmojiPresentation}, // E0.6 [2] (✊..✋) raised fist..raised hand - {0x2728, 0x2728, prEmojiPresentation}, // E0.6 [1] (✨) sparkles - {0x274C, 0x274C, prEmojiPresentation}, // E0.6 [1] (❌) cross mark - {0x274E, 0x274E, prEmojiPresentation}, // E0.6 [1] (❎) cross mark button - {0x2753, 0x2755, prEmojiPresentation}, // E0.6 [3] (❓..❕) red question mark..white exclamation mark - {0x2757, 0x2757, prEmojiPresentation}, // E0.6 [1] (❗) red exclamation mark - {0x2795, 0x2797, prEmojiPresentation}, // E0.6 [3] (➕..➗) plus..divide - {0x27B0, 0x27B0, prEmojiPresentation}, // E0.6 [1] (➰) curly loop - {0x27BF, 0x27BF, prEmojiPresentation}, // E1.0 [1] (➿) double curly loop - {0x2B1B, 0x2B1C, prEmojiPresentation}, // E0.6 [2] (⬛..⬜) black large square..white large square - {0x2B50, 0x2B50, prEmojiPresentation}, // E0.6 [1] (⭐) star - {0x2B55, 0x2B55, prEmojiPresentation}, // E0.6 [1] (⭕) hollow red circle - {0x1F004, 0x1F004, prEmojiPresentation}, // E0.6 [1] (🀄) mahjong red dragon - {0x1F0CF, 0x1F0CF, prEmojiPresentation}, // E0.6 [1] (🃏) joker - {0x1F18E, 0x1F18E, prEmojiPresentation}, // E0.6 [1] (🆎) AB button (blood type) - {0x1F191, 0x1F19A, prEmojiPresentation}, // E0.6 [10] (🆑..🆚) CL button..VS button - {0x1F1E6, 0x1F1FF, prEmojiPresentation}, // E0.0 [26] (🇦..🇿) regional indicator symbol letter a..regional indicator symbol letter z - {0x1F201, 0x1F201, prEmojiPresentation}, // E0.6 [1] (🈁) Japanese “here” button - {0x1F21A, 0x1F21A, prEmojiPresentation}, // E0.6 [1] (🈚) Japanese “free of charge” button - {0x1F22F, 0x1F22F, prEmojiPresentation}, // E0.6 [1] (🈯) Japanese “reserved” button - {0x1F232, 0x1F236, prEmojiPresentation}, // E0.6 [5] (🈲..🈶) Japanese “prohibited” button..Japanese “not free of charge” button - {0x1F238, 0x1F23A, prEmojiPresentation}, // E0.6 [3] (🈸..🈺) Japanese “application” button..Japanese “open for business” button - {0x1F250, 0x1F251, prEmojiPresentation}, // E0.6 [2] (🉐..🉑) Japanese “bargain” button..Japanese “acceptable” button - {0x1F300, 0x1F30C, prEmojiPresentation}, // E0.6 [13] (🌀..🌌) cyclone..milky way - {0x1F30D, 0x1F30E, prEmojiPresentation}, // E0.7 [2] (🌍..🌎) globe showing Europe-Africa..globe showing Americas - {0x1F30F, 0x1F30F, prEmojiPresentation}, // E0.6 [1] (🌏) globe showing Asia-Australia - {0x1F310, 0x1F310, prEmojiPresentation}, // E1.0 [1] (🌐) globe with meridians - {0x1F311, 0x1F311, prEmojiPresentation}, // E0.6 [1] (🌑) new moon - {0x1F312, 0x1F312, prEmojiPresentation}, // E1.0 [1] (🌒) waxing crescent moon - {0x1F313, 0x1F315, prEmojiPresentation}, // E0.6 [3] (🌓..🌕) first quarter moon..full moon - {0x1F316, 0x1F318, prEmojiPresentation}, // E1.0 [3] (🌖..🌘) waning gibbous moon..waning crescent moon - {0x1F319, 0x1F319, prEmojiPresentation}, // E0.6 [1] (🌙) crescent moon - {0x1F31A, 0x1F31A, prEmojiPresentation}, // E1.0 [1] (🌚) new moon face - {0x1F31B, 0x1F31B, prEmojiPresentation}, // E0.6 [1] (🌛) first quarter moon face - {0x1F31C, 0x1F31C, prEmojiPresentation}, // E0.7 [1] (🌜) last quarter moon face - {0x1F31D, 0x1F31E, prEmojiPresentation}, // E1.0 [2] (🌝..🌞) full moon face..sun with face - {0x1F31F, 0x1F320, prEmojiPresentation}, // E0.6 [2] (🌟..🌠) glowing star..shooting star - {0x1F32D, 0x1F32F, prEmojiPresentation}, // E1.0 [3] (🌭..🌯) hot dog..burrito - {0x1F330, 0x1F331, prEmojiPresentation}, // E0.6 [2] (🌰..🌱) chestnut..seedling - {0x1F332, 0x1F333, prEmojiPresentation}, // E1.0 [2] (🌲..🌳) evergreen tree..deciduous tree - {0x1F334, 0x1F335, prEmojiPresentation}, // E0.6 [2] (🌴..🌵) palm tree..cactus - {0x1F337, 0x1F34A, prEmojiPresentation}, // E0.6 [20] (🌷..🍊) tulip..tangerine - {0x1F34B, 0x1F34B, prEmojiPresentation}, // E1.0 [1] (🍋) lemon - {0x1F34C, 0x1F34F, prEmojiPresentation}, // E0.6 [4] (🍌..🍏) banana..green apple - {0x1F350, 0x1F350, prEmojiPresentation}, // E1.0 [1] (🍐) pear - {0x1F351, 0x1F37B, prEmojiPresentation}, // E0.6 [43] (🍑..🍻) peach..clinking beer mugs - {0x1F37C, 0x1F37C, prEmojiPresentation}, // E1.0 [1] (🍼) baby bottle - {0x1F37E, 0x1F37F, prEmojiPresentation}, // E1.0 [2] (🍾..🍿) bottle with popping cork..popcorn - {0x1F380, 0x1F393, prEmojiPresentation}, // E0.6 [20] (🎀..🎓) ribbon..graduation cap - {0x1F3A0, 0x1F3C4, prEmojiPresentation}, // E0.6 [37] (🎠..🏄) carousel horse..person surfing - {0x1F3C5, 0x1F3C5, prEmojiPresentation}, // E1.0 [1] (🏅) sports medal - {0x1F3C6, 0x1F3C6, prEmojiPresentation}, // E0.6 [1] (🏆) trophy - {0x1F3C7, 0x1F3C7, prEmojiPresentation}, // E1.0 [1] (🏇) horse racing - {0x1F3C8, 0x1F3C8, prEmojiPresentation}, // E0.6 [1] (🏈) american football - {0x1F3C9, 0x1F3C9, prEmojiPresentation}, // E1.0 [1] (🏉) rugby football - {0x1F3CA, 0x1F3CA, prEmojiPresentation}, // E0.6 [1] (🏊) person swimming - {0x1F3CF, 0x1F3D3, prEmojiPresentation}, // E1.0 [5] (🏏..🏓) cricket game..ping pong - {0x1F3E0, 0x1F3E3, prEmojiPresentation}, // E0.6 [4] (🏠..🏣) house..Japanese post office - {0x1F3E4, 0x1F3E4, prEmojiPresentation}, // E1.0 [1] (🏤) post office - {0x1F3E5, 0x1F3F0, prEmojiPresentation}, // E0.6 [12] (🏥..🏰) hospital..castle - {0x1F3F4, 0x1F3F4, prEmojiPresentation}, // E1.0 [1] (🏴) black flag - {0x1F3F8, 0x1F407, prEmojiPresentation}, // E1.0 [16] (🏸..🐇) badminton..rabbit - {0x1F408, 0x1F408, prEmojiPresentation}, // E0.7 [1] (🐈) cat - {0x1F409, 0x1F40B, prEmojiPresentation}, // E1.0 [3] (🐉..🐋) dragon..whale - {0x1F40C, 0x1F40E, prEmojiPresentation}, // E0.6 [3] (🐌..🐎) snail..horse - {0x1F40F, 0x1F410, prEmojiPresentation}, // E1.0 [2] (🐏..🐐) ram..goat - {0x1F411, 0x1F412, prEmojiPresentation}, // E0.6 [2] (🐑..🐒) ewe..monkey - {0x1F413, 0x1F413, prEmojiPresentation}, // E1.0 [1] (🐓) rooster - {0x1F414, 0x1F414, prEmojiPresentation}, // E0.6 [1] (🐔) chicken - {0x1F415, 0x1F415, prEmojiPresentation}, // E0.7 [1] (🐕) dog - {0x1F416, 0x1F416, prEmojiPresentation}, // E1.0 [1] (🐖) pig - {0x1F417, 0x1F429, prEmojiPresentation}, // E0.6 [19] (🐗..🐩) boar..poodle - {0x1F42A, 0x1F42A, prEmojiPresentation}, // E1.0 [1] (🐪) camel - {0x1F42B, 0x1F43E, prEmojiPresentation}, // E0.6 [20] (🐫..🐾) two-hump camel..paw prints - {0x1F440, 0x1F440, prEmojiPresentation}, // E0.6 [1] (👀) eyes - {0x1F442, 0x1F464, prEmojiPresentation}, // E0.6 [35] (👂..👤) ear..bust in silhouette - {0x1F465, 0x1F465, prEmojiPresentation}, // E1.0 [1] (👥) busts in silhouette - {0x1F466, 0x1F46B, prEmojiPresentation}, // E0.6 [6] (👦..👫) boy..woman and man holding hands - {0x1F46C, 0x1F46D, prEmojiPresentation}, // E1.0 [2] (👬..👭) men holding hands..women holding hands - {0x1F46E, 0x1F4AC, prEmojiPresentation}, // E0.6 [63] (👮..💬) police officer..speech balloon - {0x1F4AD, 0x1F4AD, prEmojiPresentation}, // E1.0 [1] (💭) thought balloon - {0x1F4AE, 0x1F4B5, prEmojiPresentation}, // E0.6 [8] (💮..💵) white flower..dollar banknote - {0x1F4B6, 0x1F4B7, prEmojiPresentation}, // E1.0 [2] (💶..💷) euro banknote..pound banknote - {0x1F4B8, 0x1F4EB, prEmojiPresentation}, // E0.6 [52] (💸..📫) money with wings..closed mailbox with raised flag - {0x1F4EC, 0x1F4ED, prEmojiPresentation}, // E0.7 [2] (📬..📭) open mailbox with raised flag..open mailbox with lowered flag - {0x1F4EE, 0x1F4EE, prEmojiPresentation}, // E0.6 [1] (📮) postbox - {0x1F4EF, 0x1F4EF, prEmojiPresentation}, // E1.0 [1] (📯) postal horn - {0x1F4F0, 0x1F4F4, prEmojiPresentation}, // E0.6 [5] (📰..📴) newspaper..mobile phone off - {0x1F4F5, 0x1F4F5, prEmojiPresentation}, // E1.0 [1] (📵) no mobile phones - {0x1F4F6, 0x1F4F7, prEmojiPresentation}, // E0.6 [2] (📶..📷) antenna bars..camera - {0x1F4F8, 0x1F4F8, prEmojiPresentation}, // E1.0 [1] (📸) camera with flash - {0x1F4F9, 0x1F4FC, prEmojiPresentation}, // E0.6 [4] (📹..📼) video camera..videocassette - {0x1F4FF, 0x1F502, prEmojiPresentation}, // E1.0 [4] (📿..🔂) prayer beads..repeat single button - {0x1F503, 0x1F503, prEmojiPresentation}, // E0.6 [1] (🔃) clockwise vertical arrows - {0x1F504, 0x1F507, prEmojiPresentation}, // E1.0 [4] (🔄..🔇) counterclockwise arrows button..muted speaker - {0x1F508, 0x1F508, prEmojiPresentation}, // E0.7 [1] (🔈) speaker low volume - {0x1F509, 0x1F509, prEmojiPresentation}, // E1.0 [1] (🔉) speaker medium volume - {0x1F50A, 0x1F514, prEmojiPresentation}, // E0.6 [11] (🔊..🔔) speaker high volume..bell - {0x1F515, 0x1F515, prEmojiPresentation}, // E1.0 [1] (🔕) bell with slash - {0x1F516, 0x1F52B, prEmojiPresentation}, // E0.6 [22] (🔖..🔫) bookmark..water pistol - {0x1F52C, 0x1F52D, prEmojiPresentation}, // E1.0 [2] (🔬..🔭) microscope..telescope - {0x1F52E, 0x1F53D, prEmojiPresentation}, // E0.6 [16] (🔮..🔽) crystal ball..downwards button - {0x1F54B, 0x1F54E, prEmojiPresentation}, // E1.0 [4] (🕋..🕎) kaaba..menorah - {0x1F550, 0x1F55B, prEmojiPresentation}, // E0.6 [12] (🕐..🕛) one o’clock..twelve o’clock - {0x1F55C, 0x1F567, prEmojiPresentation}, // E0.7 [12] (🕜..🕧) one-thirty..twelve-thirty - {0x1F57A, 0x1F57A, prEmojiPresentation}, // E3.0 [1] (🕺) man dancing - {0x1F595, 0x1F596, prEmojiPresentation}, // E1.0 [2] (🖕..🖖) middle finger..vulcan salute - {0x1F5A4, 0x1F5A4, prEmojiPresentation}, // E3.0 [1] (🖤) black heart - {0x1F5FB, 0x1F5FF, prEmojiPresentation}, // E0.6 [5] (🗻..🗿) mount fuji..moai - {0x1F600, 0x1F600, prEmojiPresentation}, // E1.0 [1] (😀) grinning face - {0x1F601, 0x1F606, prEmojiPresentation}, // E0.6 [6] (😁..😆) beaming face with smiling eyes..grinning squinting face - {0x1F607, 0x1F608, prEmojiPresentation}, // E1.0 [2] (😇..😈) smiling face with halo..smiling face with horns - {0x1F609, 0x1F60D, prEmojiPresentation}, // E0.6 [5] (😉..😍) winking face..smiling face with heart-eyes - {0x1F60E, 0x1F60E, prEmojiPresentation}, // E1.0 [1] (😎) smiling face with sunglasses - {0x1F60F, 0x1F60F, prEmojiPresentation}, // E0.6 [1] (😏) smirking face - {0x1F610, 0x1F610, prEmojiPresentation}, // E0.7 [1] (😐) neutral face - {0x1F611, 0x1F611, prEmojiPresentation}, // E1.0 [1] (😑) expressionless face - {0x1F612, 0x1F614, prEmojiPresentation}, // E0.6 [3] (😒..😔) unamused face..pensive face - {0x1F615, 0x1F615, prEmojiPresentation}, // E1.0 [1] (😕) confused face - {0x1F616, 0x1F616, prEmojiPresentation}, // E0.6 [1] (😖) confounded face - {0x1F617, 0x1F617, prEmojiPresentation}, // E1.0 [1] (😗) kissing face - {0x1F618, 0x1F618, prEmojiPresentation}, // E0.6 [1] (😘) face blowing a kiss - {0x1F619, 0x1F619, prEmojiPresentation}, // E1.0 [1] (😙) kissing face with smiling eyes - {0x1F61A, 0x1F61A, prEmojiPresentation}, // E0.6 [1] (😚) kissing face with closed eyes - {0x1F61B, 0x1F61B, prEmojiPresentation}, // E1.0 [1] (😛) face with tongue - {0x1F61C, 0x1F61E, prEmojiPresentation}, // E0.6 [3] (😜..😞) winking face with tongue..disappointed face - {0x1F61F, 0x1F61F, prEmojiPresentation}, // E1.0 [1] (😟) worried face - {0x1F620, 0x1F625, prEmojiPresentation}, // E0.6 [6] (😠..😥) angry face..sad but relieved face - {0x1F626, 0x1F627, prEmojiPresentation}, // E1.0 [2] (😦..😧) frowning face with open mouth..anguished face - {0x1F628, 0x1F62B, prEmojiPresentation}, // E0.6 [4] (😨..😫) fearful face..tired face - {0x1F62C, 0x1F62C, prEmojiPresentation}, // E1.0 [1] (😬) grimacing face - {0x1F62D, 0x1F62D, prEmojiPresentation}, // E0.6 [1] (😭) loudly crying face - {0x1F62E, 0x1F62F, prEmojiPresentation}, // E1.0 [2] (😮..😯) face with open mouth..hushed face - {0x1F630, 0x1F633, prEmojiPresentation}, // E0.6 [4] (😰..😳) anxious face with sweat..flushed face - {0x1F634, 0x1F634, prEmojiPresentation}, // E1.0 [1] (😴) sleeping face - {0x1F635, 0x1F635, prEmojiPresentation}, // E0.6 [1] (😵) face with crossed-out eyes - {0x1F636, 0x1F636, prEmojiPresentation}, // E1.0 [1] (😶) face without mouth - {0x1F637, 0x1F640, prEmojiPresentation}, // E0.6 [10] (😷..🙀) face with medical mask..weary cat - {0x1F641, 0x1F644, prEmojiPresentation}, // E1.0 [4] (🙁..🙄) slightly frowning face..face with rolling eyes - {0x1F645, 0x1F64F, prEmojiPresentation}, // E0.6 [11] (🙅..🙏) person gesturing NO..folded hands - {0x1F680, 0x1F680, prEmojiPresentation}, // E0.6 [1] (🚀) rocket - {0x1F681, 0x1F682, prEmojiPresentation}, // E1.0 [2] (🚁..🚂) helicopter..locomotive - {0x1F683, 0x1F685, prEmojiPresentation}, // E0.6 [3] (🚃..🚅) railway car..bullet train - {0x1F686, 0x1F686, prEmojiPresentation}, // E1.0 [1] (🚆) train - {0x1F687, 0x1F687, prEmojiPresentation}, // E0.6 [1] (🚇) metro - {0x1F688, 0x1F688, prEmojiPresentation}, // E1.0 [1] (🚈) light rail - {0x1F689, 0x1F689, prEmojiPresentation}, // E0.6 [1] (🚉) station - {0x1F68A, 0x1F68B, prEmojiPresentation}, // E1.0 [2] (🚊..🚋) tram..tram car - {0x1F68C, 0x1F68C, prEmojiPresentation}, // E0.6 [1] (🚌) bus - {0x1F68D, 0x1F68D, prEmojiPresentation}, // E0.7 [1] (🚍) oncoming bus - {0x1F68E, 0x1F68E, prEmojiPresentation}, // E1.0 [1] (🚎) trolleybus - {0x1F68F, 0x1F68F, prEmojiPresentation}, // E0.6 [1] (🚏) bus stop - {0x1F690, 0x1F690, prEmojiPresentation}, // E1.0 [1] (🚐) minibus - {0x1F691, 0x1F693, prEmojiPresentation}, // E0.6 [3] (🚑..🚓) ambulance..police car - {0x1F694, 0x1F694, prEmojiPresentation}, // E0.7 [1] (🚔) oncoming police car - {0x1F695, 0x1F695, prEmojiPresentation}, // E0.6 [1] (🚕) taxi - {0x1F696, 0x1F696, prEmojiPresentation}, // E1.0 [1] (🚖) oncoming taxi - {0x1F697, 0x1F697, prEmojiPresentation}, // E0.6 [1] (🚗) automobile - {0x1F698, 0x1F698, prEmojiPresentation}, // E0.7 [1] (🚘) oncoming automobile - {0x1F699, 0x1F69A, prEmojiPresentation}, // E0.6 [2] (🚙..🚚) sport utility vehicle..delivery truck - {0x1F69B, 0x1F6A1, prEmojiPresentation}, // E1.0 [7] (🚛..🚡) articulated lorry..aerial tramway - {0x1F6A2, 0x1F6A2, prEmojiPresentation}, // E0.6 [1] (🚢) ship - {0x1F6A3, 0x1F6A3, prEmojiPresentation}, // E1.0 [1] (🚣) person rowing boat - {0x1F6A4, 0x1F6A5, prEmojiPresentation}, // E0.6 [2] (🚤..🚥) speedboat..horizontal traffic light - {0x1F6A6, 0x1F6A6, prEmojiPresentation}, // E1.0 [1] (🚦) vertical traffic light - {0x1F6A7, 0x1F6AD, prEmojiPresentation}, // E0.6 [7] (🚧..🚭) construction..no smoking - {0x1F6AE, 0x1F6B1, prEmojiPresentation}, // E1.0 [4] (🚮..🚱) litter in bin sign..non-potable water - {0x1F6B2, 0x1F6B2, prEmojiPresentation}, // E0.6 [1] (🚲) bicycle - {0x1F6B3, 0x1F6B5, prEmojiPresentation}, // E1.0 [3] (🚳..🚵) no bicycles..person mountain biking - {0x1F6B6, 0x1F6B6, prEmojiPresentation}, // E0.6 [1] (🚶) person walking - {0x1F6B7, 0x1F6B8, prEmojiPresentation}, // E1.0 [2] (🚷..🚸) no pedestrians..children crossing - {0x1F6B9, 0x1F6BE, prEmojiPresentation}, // E0.6 [6] (🚹..🚾) men’s room..water closet - {0x1F6BF, 0x1F6BF, prEmojiPresentation}, // E1.0 [1] (🚿) shower - {0x1F6C0, 0x1F6C0, prEmojiPresentation}, // E0.6 [1] (🛀) person taking bath - {0x1F6C1, 0x1F6C5, prEmojiPresentation}, // E1.0 [5] (🛁..🛅) bathtub..left luggage - {0x1F6CC, 0x1F6CC, prEmojiPresentation}, // E1.0 [1] (🛌) person in bed - {0x1F6D0, 0x1F6D0, prEmojiPresentation}, // E1.0 [1] (🛐) place of worship - {0x1F6D1, 0x1F6D2, prEmojiPresentation}, // E3.0 [2] (🛑..🛒) stop sign..shopping cart - {0x1F6D5, 0x1F6D5, prEmojiPresentation}, // E12.0 [1] (🛕) hindu temple - {0x1F6D6, 0x1F6D7, prEmojiPresentation}, // E13.0 [2] (🛖..🛗) hut..elevator - {0x1F6DC, 0x1F6DC, prEmojiPresentation}, // E15.0 [1] (🛜) wireless - {0x1F6DD, 0x1F6DF, prEmojiPresentation}, // E14.0 [3] (🛝..🛟) playground slide..ring buoy - {0x1F6EB, 0x1F6EC, prEmojiPresentation}, // E1.0 [2] (🛫..🛬) airplane departure..airplane arrival - {0x1F6F4, 0x1F6F6, prEmojiPresentation}, // E3.0 [3] (🛴..🛶) kick scooter..canoe - {0x1F6F7, 0x1F6F8, prEmojiPresentation}, // E5.0 [2] (🛷..🛸) sled..flying saucer - {0x1F6F9, 0x1F6F9, prEmojiPresentation}, // E11.0 [1] (🛹) skateboard - {0x1F6FA, 0x1F6FA, prEmojiPresentation}, // E12.0 [1] (🛺) auto rickshaw - {0x1F6FB, 0x1F6FC, prEmojiPresentation}, // E13.0 [2] (🛻..🛼) pickup truck..roller skate - {0x1F7E0, 0x1F7EB, prEmojiPresentation}, // E12.0 [12] (🟠..🟫) orange circle..brown square - {0x1F7F0, 0x1F7F0, prEmojiPresentation}, // E14.0 [1] (🟰) heavy equals sign - {0x1F90C, 0x1F90C, prEmojiPresentation}, // E13.0 [1] (🤌) pinched fingers - {0x1F90D, 0x1F90F, prEmojiPresentation}, // E12.0 [3] (🤍..🤏) white heart..pinching hand - {0x1F910, 0x1F918, prEmojiPresentation}, // E1.0 [9] (🤐..🤘) zipper-mouth face..sign of the horns - {0x1F919, 0x1F91E, prEmojiPresentation}, // E3.0 [6] (🤙..🤞) call me hand..crossed fingers - {0x1F91F, 0x1F91F, prEmojiPresentation}, // E5.0 [1] (🤟) love-you gesture - {0x1F920, 0x1F927, prEmojiPresentation}, // E3.0 [8] (🤠..🤧) cowboy hat face..sneezing face - {0x1F928, 0x1F92F, prEmojiPresentation}, // E5.0 [8] (🤨..🤯) face with raised eyebrow..exploding head - {0x1F930, 0x1F930, prEmojiPresentation}, // E3.0 [1] (🤰) pregnant woman - {0x1F931, 0x1F932, prEmojiPresentation}, // E5.0 [2] (🤱..🤲) breast-feeding..palms up together - {0x1F933, 0x1F93A, prEmojiPresentation}, // E3.0 [8] (🤳..🤺) selfie..person fencing - {0x1F93C, 0x1F93E, prEmojiPresentation}, // E3.0 [3] (🤼..🤾) people wrestling..person playing handball - {0x1F93F, 0x1F93F, prEmojiPresentation}, // E12.0 [1] (🤿) diving mask - {0x1F940, 0x1F945, prEmojiPresentation}, // E3.0 [6] (🥀..🥅) wilted flower..goal net - {0x1F947, 0x1F94B, prEmojiPresentation}, // E3.0 [5] (🥇..🥋) 1st place medal..martial arts uniform - {0x1F94C, 0x1F94C, prEmojiPresentation}, // E5.0 [1] (🥌) curling stone - {0x1F94D, 0x1F94F, prEmojiPresentation}, // E11.0 [3] (🥍..🥏) lacrosse..flying disc - {0x1F950, 0x1F95E, prEmojiPresentation}, // E3.0 [15] (🥐..🥞) croissant..pancakes - {0x1F95F, 0x1F96B, prEmojiPresentation}, // E5.0 [13] (🥟..🥫) dumpling..canned food - {0x1F96C, 0x1F970, prEmojiPresentation}, // E11.0 [5] (🥬..🥰) leafy green..smiling face with hearts - {0x1F971, 0x1F971, prEmojiPresentation}, // E12.0 [1] (🥱) yawning face - {0x1F972, 0x1F972, prEmojiPresentation}, // E13.0 [1] (🥲) smiling face with tear - {0x1F973, 0x1F976, prEmojiPresentation}, // E11.0 [4] (🥳..🥶) partying face..cold face - {0x1F977, 0x1F978, prEmojiPresentation}, // E13.0 [2] (🥷..🥸) ninja..disguised face - {0x1F979, 0x1F979, prEmojiPresentation}, // E14.0 [1] (🥹) face holding back tears - {0x1F97A, 0x1F97A, prEmojiPresentation}, // E11.0 [1] (🥺) pleading face - {0x1F97B, 0x1F97B, prEmojiPresentation}, // E12.0 [1] (🥻) sari - {0x1F97C, 0x1F97F, prEmojiPresentation}, // E11.0 [4] (🥼..🥿) lab coat..flat shoe - {0x1F980, 0x1F984, prEmojiPresentation}, // E1.0 [5] (🦀..🦄) crab..unicorn - {0x1F985, 0x1F991, prEmojiPresentation}, // E3.0 [13] (🦅..🦑) eagle..squid - {0x1F992, 0x1F997, prEmojiPresentation}, // E5.0 [6] (🦒..🦗) giraffe..cricket - {0x1F998, 0x1F9A2, prEmojiPresentation}, // E11.0 [11] (🦘..🦢) kangaroo..swan - {0x1F9A3, 0x1F9A4, prEmojiPresentation}, // E13.0 [2] (🦣..🦤) mammoth..dodo - {0x1F9A5, 0x1F9AA, prEmojiPresentation}, // E12.0 [6] (🦥..🦪) sloth..oyster - {0x1F9AB, 0x1F9AD, prEmojiPresentation}, // E13.0 [3] (🦫..🦭) beaver..seal - {0x1F9AE, 0x1F9AF, prEmojiPresentation}, // E12.0 [2] (🦮..🦯) guide dog..white cane - {0x1F9B0, 0x1F9B9, prEmojiPresentation}, // E11.0 [10] (🦰..🦹) red hair..supervillain - {0x1F9BA, 0x1F9BF, prEmojiPresentation}, // E12.0 [6] (🦺..🦿) safety vest..mechanical leg - {0x1F9C0, 0x1F9C0, prEmojiPresentation}, // E1.0 [1] (🧀) cheese wedge - {0x1F9C1, 0x1F9C2, prEmojiPresentation}, // E11.0 [2] (🧁..🧂) cupcake..salt - {0x1F9C3, 0x1F9CA, prEmojiPresentation}, // E12.0 [8] (🧃..🧊) beverage box..ice - {0x1F9CB, 0x1F9CB, prEmojiPresentation}, // E13.0 [1] (🧋) bubble tea - {0x1F9CC, 0x1F9CC, prEmojiPresentation}, // E14.0 [1] (🧌) troll - {0x1F9CD, 0x1F9CF, prEmojiPresentation}, // E12.0 [3] (🧍..🧏) person standing..deaf person - {0x1F9D0, 0x1F9E6, prEmojiPresentation}, // E5.0 [23] (🧐..🧦) face with monocle..socks - {0x1F9E7, 0x1F9FF, prEmojiPresentation}, // E11.0 [25] (🧧..🧿) red envelope..nazar amulet - {0x1FA70, 0x1FA73, prEmojiPresentation}, // E12.0 [4] (🩰..🩳) ballet shoes..shorts - {0x1FA74, 0x1FA74, prEmojiPresentation}, // E13.0 [1] (🩴) thong sandal - {0x1FA75, 0x1FA77, prEmojiPresentation}, // E15.0 [3] (🩵..🩷) light blue heart..pink heart - {0x1FA78, 0x1FA7A, prEmojiPresentation}, // E12.0 [3] (🩸..🩺) drop of blood..stethoscope - {0x1FA7B, 0x1FA7C, prEmojiPresentation}, // E14.0 [2] (🩻..🩼) x-ray..crutch - {0x1FA80, 0x1FA82, prEmojiPresentation}, // E12.0 [3] (🪀..🪂) yo-yo..parachute - {0x1FA83, 0x1FA86, prEmojiPresentation}, // E13.0 [4] (🪃..🪆) boomerang..nesting dolls - {0x1FA87, 0x1FA88, prEmojiPresentation}, // E15.0 [2] (🪇..🪈) maracas..flute - {0x1FA90, 0x1FA95, prEmojiPresentation}, // E12.0 [6] (🪐..🪕) ringed planet..banjo - {0x1FA96, 0x1FAA8, prEmojiPresentation}, // E13.0 [19] (🪖..🪨) military helmet..rock - {0x1FAA9, 0x1FAAC, prEmojiPresentation}, // E14.0 [4] (🪩..🪬) mirror ball..hamsa - {0x1FAAD, 0x1FAAF, prEmojiPresentation}, // E15.0 [3] (🪭..🪯) folding hand fan..khanda - {0x1FAB0, 0x1FAB6, prEmojiPresentation}, // E13.0 [7] (🪰..🪶) fly..feather - {0x1FAB7, 0x1FABA, prEmojiPresentation}, // E14.0 [4] (🪷..🪺) lotus..nest with eggs - {0x1FABB, 0x1FABD, prEmojiPresentation}, // E15.0 [3] (🪻..🪽) hyacinth..wing - {0x1FABF, 0x1FABF, prEmojiPresentation}, // E15.0 [1] (🪿) goose - {0x1FAC0, 0x1FAC2, prEmojiPresentation}, // E13.0 [3] (🫀..🫂) anatomical heart..people hugging - {0x1FAC3, 0x1FAC5, prEmojiPresentation}, // E14.0 [3] (🫃..🫅) pregnant man..person with crown - {0x1FACE, 0x1FACF, prEmojiPresentation}, // E15.0 [2] (🫎..🫏) moose..donkey - {0x1FAD0, 0x1FAD6, prEmojiPresentation}, // E13.0 [7] (🫐..🫖) blueberries..teapot - {0x1FAD7, 0x1FAD9, prEmojiPresentation}, // E14.0 [3] (🫗..🫙) pouring liquid..jar - {0x1FADA, 0x1FADB, prEmojiPresentation}, // E15.0 [2] (🫚..🫛) ginger root..pea pod - {0x1FAE0, 0x1FAE7, prEmojiPresentation}, // E14.0 [8] (🫠..🫧) melting face..bubbles - {0x1FAE8, 0x1FAE8, prEmojiPresentation}, // E15.0 [1] (🫨) shaking face - {0x1FAF0, 0x1FAF6, prEmojiPresentation}, // E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands - {0x1FAF7, 0x1FAF8, prEmojiPresentation}, // E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand -} diff --git a/vendor/github.com/rivo/uniseg/gen_breaktest.go b/vendor/github.com/rivo/uniseg/gen_breaktest.go deleted file mode 100644 index 6bfbeb5..0000000 --- a/vendor/github.com/rivo/uniseg/gen_breaktest.go +++ /dev/null @@ -1,215 +0,0 @@ -//go:build generate - -// This program generates a Go containing a slice of test cases based on the -// Unicode Character Database auxiliary data files. The command line arguments -// are as follows: -// -// 1. The name of the Unicode data file (just the filename, without extension). -// 2. The name of the locally generated Go file. -// 3. The name of the slice containing the test cases. -// 4. The name of the generator, for logging purposes. -// -//go:generate go run gen_breaktest.go GraphemeBreakTest graphemebreak_test.go graphemeBreakTestCases graphemes -//go:generate go run gen_breaktest.go WordBreakTest wordbreak_test.go wordBreakTestCases words -//go:generate go run gen_breaktest.go SentenceBreakTest sentencebreak_test.go sentenceBreakTestCases sentences -//go:generate go run gen_breaktest.go LineBreakTest linebreak_test.go lineBreakTestCases lines - -package main - -import ( - "bufio" - "bytes" - "errors" - "fmt" - "go/format" - "io/ioutil" - "log" - "net/http" - "os" - "time" -) - -// We want to test against a specific version rather than the latest. When the -// package is upgraded to a new version, change these to generate new tests. -const ( - testCaseURL = `https://www.unicode.org/Public/15.0.0/ucd/auxiliary/%s.txt` -) - -func main() { - if len(os.Args) < 5 { - fmt.Println("Not enough arguments, see code for details") - os.Exit(1) - } - - log.SetPrefix("gen_breaktest (" + os.Args[4] + "): ") - log.SetFlags(0) - - // Read text of testcases and parse into Go source code. - src, err := parse(fmt.Sprintf(testCaseURL, os.Args[1])) - if err != nil { - log.Fatal(err) - } - - // Format the Go code. - formatted, err := format.Source(src) - if err != nil { - log.Fatalln("gofmt:", err) - } - - // Write it out. - log.Print("Writing to ", os.Args[2]) - if err := ioutil.WriteFile(os.Args[2], formatted, 0644); err != nil { - log.Fatal(err) - } -} - -// parse reads a break text file, either from a local file or from a URL. It -// parses the file data into Go source code representing the test cases. -func parse(url string) ([]byte, error) { - log.Printf("Parsing %s", url) - res, err := http.Get(url) - if err != nil { - return nil, err - } - body := res.Body - defer body.Close() - - buf := new(bytes.Buffer) - buf.Grow(120 << 10) - buf.WriteString(`// Code generated via go generate from gen_breaktest.go. DO NOT EDIT. - -package uniseg - -// ` + os.Args[3] + ` are Grapheme testcases taken from -// ` + url + ` -// on ` + time.Now().Format("January 2, 2006") + `. See -// https://www.unicode.org/license.html for the Unicode license agreement. -var ` + os.Args[3] + ` = []testCase { -`) - - sc := bufio.NewScanner(body) - num := 1 - var line []byte - original := make([]byte, 0, 64) - expected := make([]byte, 0, 64) - for sc.Scan() { - num++ - line = sc.Bytes() - if len(line) == 0 || line[0] == '#' { - continue - } - var comment []byte - if i := bytes.IndexByte(line, '#'); i >= 0 { - comment = bytes.TrimSpace(line[i+1:]) - line = bytes.TrimSpace(line[:i]) - } - original, expected, err := parseRuneSequence(line, original[:0], expected[:0]) - if err != nil { - return nil, fmt.Errorf(`line %d: %v: %q`, num, err, line) - } - fmt.Fprintf(buf, "\t{original: \"%s\", expected: %s}, // %s\n", original, expected, comment) - } - if err := sc.Err(); err != nil { - return nil, err - } - - // Check for final "# EOF", useful check if we're streaming via HTTP - if !bytes.Equal(line, []byte("# EOF")) { - return nil, fmt.Errorf(`line %d: exected "# EOF" as final line, got %q`, num, line) - } - buf.WriteString("}\n") - return buf.Bytes(), nil -} - -// Used by parseRuneSequence to match input via bytes.HasPrefix. -var ( - prefixBreak = []byte("÷ ") - prefixDontBreak = []byte("× ") - breakOk = []byte("÷") - breakNo = []byte("×") -) - -// parseRuneSequence parses a rune + breaking opportunity sequence from b -// and appends the Go code for testcase.original to orig -// and appends the Go code for testcase.expected to exp. -// It retuns the new orig and exp slices. -// -// E.g. for the input b="÷ 0020 × 0308 ÷ 1F1E6 ÷" -// it will append -// -// "\u0020\u0308\U0001F1E6" -// -// and "[][]rune{{0x0020,0x0308},{0x1F1E6},}" -// to orig and exp respectively. -// -// The formatting of exp is expected to be cleaned up by gofmt or format.Source. -// Note we explicitly require the sequence to start with ÷ and we implicitly -// require it to end with ÷. -func parseRuneSequence(b, orig, exp []byte) ([]byte, []byte, error) { - // Check for and remove first ÷ or ×. - if !bytes.HasPrefix(b, prefixBreak) && !bytes.HasPrefix(b, prefixDontBreak) { - return nil, nil, errors.New("expected ÷ or × as first character") - } - if bytes.HasPrefix(b, prefixBreak) { - b = b[len(prefixBreak):] - } else { - b = b[len(prefixDontBreak):] - } - - boundary := true - exp = append(exp, "[][]rune{"...) - for len(b) > 0 { - if boundary { - exp = append(exp, '{') - } - exp = append(exp, "0x"...) - // Find end of hex digits. - var i int - for i = 0; i < len(b) && b[i] != ' '; i++ { - if d := b[i]; ('0' <= d || d <= '9') || - ('A' <= d || d <= 'F') || - ('a' <= d || d <= 'f') { - continue - } - return nil, nil, errors.New("bad hex digit") - } - switch i { - case 4: - orig = append(orig, "\\u"...) - case 5: - orig = append(orig, "\\U000"...) - default: - return nil, nil, errors.New("unsupport code point hex length") - } - orig = append(orig, b[:i]...) - exp = append(exp, b[:i]...) - b = b[i:] - - // Check for space between hex and ÷ or ×. - if len(b) < 1 || b[0] != ' ' { - return nil, nil, errors.New("bad input") - } - b = b[1:] - - // Check for next boundary. - switch { - case bytes.HasPrefix(b, breakOk): - boundary = true - b = b[len(breakOk):] - case bytes.HasPrefix(b, breakNo): - boundary = false - b = b[len(breakNo):] - default: - return nil, nil, errors.New("missing ÷ or ×") - } - if boundary { - exp = append(exp, '}') - } - exp = append(exp, ',') - if len(b) > 0 && b[0] == ' ' { - b = b[1:] - } - } - exp = append(exp, '}') - return orig, exp, nil -} diff --git a/vendor/github.com/rivo/uniseg/gen_properties.go b/vendor/github.com/rivo/uniseg/gen_properties.go deleted file mode 100644 index 8992d2c..0000000 --- a/vendor/github.com/rivo/uniseg/gen_properties.go +++ /dev/null @@ -1,261 +0,0 @@ -//go:build generate - -// This program generates a property file in Go file from Unicode Character -// Database auxiliary data files. The command line arguments are as follows: -// -// 1. The name of the Unicode data file (just the filename, without extension). -// Can be "-" (to skip) if the emoji flag is included. -// 2. The name of the locally generated Go file. -// 3. The name of the slice mapping code points to properties. -// 4. The name of the generator, for logging purposes. -// 5. (Optional) Flags, comma-separated. The following flags are available: -// - "emojis=": include the specified emoji properties (e.g. -// "Extended_Pictographic"). -// - "gencat": include general category properties. -// -//go:generate go run gen_properties.go auxiliary/GraphemeBreakProperty graphemeproperties.go graphemeCodePoints graphemes emojis=Extended_Pictographic -//go:generate go run gen_properties.go auxiliary/WordBreakProperty wordproperties.go workBreakCodePoints words emojis=Extended_Pictographic -//go:generate go run gen_properties.go auxiliary/SentenceBreakProperty sentenceproperties.go sentenceBreakCodePoints sentences -//go:generate go run gen_properties.go LineBreak lineproperties.go lineBreakCodePoints lines gencat -//go:generate go run gen_properties.go EastAsianWidth eastasianwidth.go eastAsianWidth eastasianwidth -//go:generate go run gen_properties.go - emojipresentation.go emojiPresentation emojipresentation emojis=Emoji_Presentation -package main - -import ( - "bufio" - "bytes" - "errors" - "fmt" - "go/format" - "io/ioutil" - "log" - "net/http" - "os" - "regexp" - "sort" - "strconv" - "strings" - "time" -) - -// We want to test against a specific version rather than the latest. When the -// package is upgraded to a new version, change these to generate new tests. -const ( - propertyURL = `https://www.unicode.org/Public/15.0.0/ucd/%s.txt` - emojiURL = `https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt` -) - -// The regular expression for a line containing a code point range property. -var propertyPattern = regexp.MustCompile(`^([0-9A-F]{4,6})(\.\.([0-9A-F]{4,6}))?\s*;\s*([A-Za-z0-9_]+)\s*#\s(.+)$`) - -func main() { - if len(os.Args) < 5 { - fmt.Println("Not enough arguments, see code for details") - os.Exit(1) - } - - log.SetPrefix("gen_properties (" + os.Args[4] + "): ") - log.SetFlags(0) - - // Parse flags. - flags := make(map[string]string) - if len(os.Args) >= 6 { - for _, flag := range strings.Split(os.Args[5], ",") { - flagFields := strings.Split(flag, "=") - if len(flagFields) == 1 { - flags[flagFields[0]] = "yes" - } else { - flags[flagFields[0]] = flagFields[1] - } - } - } - - // Parse the text file and generate Go source code from it. - _, includeGeneralCategory := flags["gencat"] - var mainURL string - if os.Args[1] != "-" { - mainURL = fmt.Sprintf(propertyURL, os.Args[1]) - } - src, err := parse(mainURL, flags["emojis"], includeGeneralCategory) - if err != nil { - log.Fatal(err) - } - - // Format the Go code. - formatted, err := format.Source([]byte(src)) - if err != nil { - log.Fatal("gofmt:", err) - } - - // Save it to the (local) target file. - log.Print("Writing to ", os.Args[2]) - if err := ioutil.WriteFile(os.Args[2], formatted, 0644); err != nil { - log.Fatal(err) - } -} - -// parse parses the Unicode Properties text files located at the given URLs and -// returns their equivalent Go source code to be used in the uniseg package. If -// "emojiProperty" is not an empty string, emoji code points for that emoji -// property (e.g. "Extended_Pictographic") will be included. In those cases, you -// may pass an empty "propertyURL" to skip parsing the main properties file. If -// "includeGeneralCategory" is true, the Unicode General Category property will -// be extracted from the comments and included in the output. -func parse(propertyURL, emojiProperty string, includeGeneralCategory bool) (string, error) { - if propertyURL == "" && emojiProperty == "" { - return "", errors.New("no properties to parse") - } - - // Temporary buffer to hold properties. - var properties [][4]string - - // Open the first URL. - if propertyURL != "" { - log.Printf("Parsing %s", propertyURL) - res, err := http.Get(propertyURL) - if err != nil { - return "", err - } - in1 := res.Body - defer in1.Close() - - // Parse it. - scanner := bufio.NewScanner(in1) - num := 0 - for scanner.Scan() { - num++ - line := strings.TrimSpace(scanner.Text()) - - // Skip comments and empty lines. - if strings.HasPrefix(line, "#") || line == "" { - continue - } - - // Everything else must be a code point range, a property and a comment. - from, to, property, comment, err := parseProperty(line) - if err != nil { - return "", fmt.Errorf("%s line %d: %v", os.Args[4], num, err) - } - properties = append(properties, [4]string{from, to, property, comment}) - } - if err := scanner.Err(); err != nil { - return "", err - } - } - - // Open the second URL. - if emojiProperty != "" { - log.Printf("Parsing %s", emojiURL) - res, err := http.Get(emojiURL) - if err != nil { - return "", err - } - in2 := res.Body - defer in2.Close() - - // Parse it. - scanner := bufio.NewScanner(in2) - num := 0 - for scanner.Scan() { - num++ - line := scanner.Text() - - // Skip comments, empty lines, and everything not containing - // "Extended_Pictographic". - if strings.HasPrefix(line, "#") || line == "" || !strings.Contains(line, emojiProperty) { - continue - } - - // Everything else must be a code point range, a property and a comment. - from, to, property, comment, err := parseProperty(line) - if err != nil { - return "", fmt.Errorf("emojis line %d: %v", num, err) - } - properties = append(properties, [4]string{from, to, property, comment}) - } - if err := scanner.Err(); err != nil { - return "", err - } - } - - // Avoid overflow during binary search. - if len(properties) >= 1<<31 { - return "", errors.New("too many properties") - } - - // Sort properties. - sort.Slice(properties, func(i, j int) bool { - left, _ := strconv.ParseUint(properties[i][0], 16, 64) - right, _ := strconv.ParseUint(properties[j][0], 16, 64) - return left < right - }) - - // Header. - var ( - buf bytes.Buffer - emojiComment string - ) - columns := 3 - if includeGeneralCategory { - columns = 4 - } - if emojiURL != "" { - emojiComment = ` -// and -// ` + emojiURL + ` -// ("Extended_Pictographic" only)` - } - buf.WriteString(`// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// ` + os.Args[3] + ` are taken from -// ` + propertyURL + emojiComment + ` -// on ` + time.Now().Format("January 2, 2006") + `. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var ` + os.Args[3] + ` = [][` + strconv.Itoa(columns) + `]int{ - `) - - // Properties. - for _, prop := range properties { - if includeGeneralCategory { - generalCategory := "gc" + prop[3][:2] - if generalCategory == "gcL&" { - generalCategory = "gcLC" - } - prop[3] = prop[3][3:] - fmt.Fprintf(&buf, "{0x%s,0x%s,%s,%s}, // %s\n", prop[0], prop[1], translateProperty("pr", prop[2]), generalCategory, prop[3]) - } else { - fmt.Fprintf(&buf, "{0x%s,0x%s,%s}, // %s\n", prop[0], prop[1], translateProperty("pr", prop[2]), prop[3]) - } - } - - // Tail. - buf.WriteString("}") - - return buf.String(), nil -} - -// parseProperty parses a line of the Unicode properties text file containing a -// property for a code point range and returns it along with its comment. -func parseProperty(line string) (from, to, property, comment string, err error) { - fields := propertyPattern.FindStringSubmatch(line) - if fields == nil { - err = errors.New("no property found") - return - } - from = fields[1] - to = fields[3] - if to == "" { - to = from - } - property = fields[4] - comment = fields[5] - return -} - -// translateProperty translates a property name as used in the Unicode data file -// to a variable used in the Go code. -func translateProperty(prefix, property string) string { - return prefix + strings.ReplaceAll(property, "_", "") -} diff --git a/vendor/github.com/rivo/uniseg/grapheme.go b/vendor/github.com/rivo/uniseg/grapheme.go deleted file mode 100644 index b12403d..0000000 --- a/vendor/github.com/rivo/uniseg/grapheme.go +++ /dev/null @@ -1,331 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// Graphemes implements an iterator over Unicode grapheme clusters, or -// user-perceived characters. While iterating, it also provides information -// about word boundaries, sentence boundaries, line breaks, and monospace -// character widths. -// -// After constructing the class via [NewGraphemes] for a given string "str", -// [Graphemes.Next] is called for every grapheme cluster in a loop until it -// returns false. Inside the loop, information about the grapheme cluster as -// well as boundary information and character width is available via the various -// methods (see examples below). -// -// This class basically wraps the [StepString] parser and provides a convenient -// interface to it. If you are only interested in some parts of this package's -// functionality, using the specialized functions starting with "First" is -// almost always faster. -type Graphemes struct { - // The original string. - original string - - // The remaining string to be parsed. - remaining string - - // The current grapheme cluster. - cluster string - - // The byte offset of the current grapheme cluster relative to the original - // string. - offset int - - // The current boundary information of the [Step] parser. - boundaries int - - // The current state of the [Step] parser. - state int -} - -// NewGraphemes returns a new grapheme cluster iterator. -func NewGraphemes(str string) *Graphemes { - return &Graphemes{ - original: str, - remaining: str, - state: -1, - } -} - -// Next advances the iterator by one grapheme cluster and returns false if no -// clusters are left. This function must be called before the first cluster is -// accessed. -func (g *Graphemes) Next() bool { - if len(g.remaining) == 0 { - // We're already past the end. - g.state = -2 - g.cluster = "" - return false - } - g.offset += len(g.cluster) - g.cluster, g.remaining, g.boundaries, g.state = StepString(g.remaining, g.state) - return true -} - -// Runes returns a slice of runes (code points) which corresponds to the current -// grapheme cluster. If the iterator is already past the end or [Graphemes.Next] -// has not yet been called, nil is returned. -func (g *Graphemes) Runes() []rune { - if g.state < 0 { - return nil - } - return []rune(g.cluster) -} - -// Str returns a substring of the original string which corresponds to the -// current grapheme cluster. If the iterator is already past the end or -// [Graphemes.Next] has not yet been called, an empty string is returned. -func (g *Graphemes) Str() string { - return g.cluster -} - -// Bytes returns a byte slice which corresponds to the current grapheme cluster. -// If the iterator is already past the end or [Graphemes.Next] has not yet been -// called, nil is returned. -func (g *Graphemes) Bytes() []byte { - if g.state < 0 { - return nil - } - return []byte(g.cluster) -} - -// Positions returns the interval of the current grapheme cluster as byte -// positions into the original string. The first returned value "from" indexes -// the first byte and the second returned value "to" indexes the first byte that -// is not included anymore, i.e. str[from:to] is the current grapheme cluster of -// the original string "str". If [Graphemes.Next] has not yet been called, both -// values are 0. If the iterator is already past the end, both values are 1. -func (g *Graphemes) Positions() (int, int) { - if g.state == -1 { - return 0, 0 - } else if g.state == -2 { - return 1, 1 - } - return g.offset, g.offset + len(g.cluster) -} - -// IsWordBoundary returns true if a word ends after the current grapheme -// cluster. -func (g *Graphemes) IsWordBoundary() bool { - if g.state < 0 { - return true - } - return g.boundaries&MaskWord != 0 -} - -// IsSentenceBoundary returns true if a sentence ends after the current -// grapheme cluster. -func (g *Graphemes) IsSentenceBoundary() bool { - if g.state < 0 { - return true - } - return g.boundaries&MaskSentence != 0 -} - -// LineBreak returns whether the line can be broken after the current grapheme -// cluster. A value of [LineDontBreak] means the line may not be broken, a value -// of [LineMustBreak] means the line must be broken, and a value of -// [LineCanBreak] means the line may or may not be broken. -func (g *Graphemes) LineBreak() int { - if g.state == -1 { - return LineDontBreak - } - if g.state == -2 { - return LineMustBreak - } - return g.boundaries & MaskLine -} - -// Width returns the monospace width of the current grapheme cluster. -func (g *Graphemes) Width() int { - if g.state < 0 { - return 0 - } - return g.boundaries >> ShiftWidth -} - -// Reset puts the iterator into its initial state such that the next call to -// [Graphemes.Next] sets it to the first grapheme cluster again. -func (g *Graphemes) Reset() { - g.state = -1 - g.offset = 0 - g.cluster = "" - g.remaining = g.original -} - -// GraphemeClusterCount returns the number of user-perceived characters -// (grapheme clusters) for the given string. -func GraphemeClusterCount(s string) (n int) { - state := -1 - for len(s) > 0 { - _, s, _, state = FirstGraphemeClusterInString(s, state) - n++ - } - return -} - -// ReverseString reverses the given string while observing grapheme cluster -// boundaries. -func ReverseString(s string) string { - str := []byte(s) - reversed := make([]byte, len(str)) - state := -1 - index := len(str) - for len(str) > 0 { - var cluster []byte - cluster, str, _, state = FirstGraphemeCluster(str, state) - index -= len(cluster) - copy(reversed[index:], cluster) - if index <= len(str)/2 { - break - } - } - return string(reversed) -} - -// The number of bits the grapheme property must be shifted to make place for -// grapheme states. -const shiftGraphemePropState = 4 - -// FirstGraphemeCluster returns the first grapheme cluster found in the given -// byte slice according to the rules of [Unicode Standard Annex #29, Grapheme -// Cluster Boundaries]. This function can be called continuously to extract all -// grapheme clusters from a byte slice, as illustrated in the example below. -// -// If you don't know the current state, for example when calling the function -// for the first time, you must pass -1. For consecutive calls, pass the state -// and rest slice returned by the previous call. -// -// The "rest" slice is the sub-slice of the original byte slice "b" starting -// after the last byte of the identified grapheme cluster. If the length of the -// "rest" slice is 0, the entire byte slice "b" has been processed. The -// "cluster" byte slice is the sub-slice of the input slice containing the -// identified grapheme cluster. -// -// The returned width is the width of the grapheme cluster for most monospace -// fonts where a value of 1 represents one character cell. -// -// Given an empty byte slice "b", the function returns nil values. -// -// While slightly less convenient than using the Graphemes class, this function -// has much better performance and makes no allocations. It lends itself well to -// large byte slices. -// -// [Unicode Standard Annex #29, Grapheme Cluster Boundaries]: http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries -func FirstGraphemeCluster(b []byte, state int) (cluster, rest []byte, width, newState int) { - // An empty byte slice returns nothing. - if len(b) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRune(b) - if len(b) <= length { // If we're already past the end, there is nothing else to parse. - var prop int - if state < 0 { - prop = propertyGraphemes(r) - } else { - prop = state >> shiftGraphemePropState - } - return b, nil, runeWidth(r, prop), grAny | (prop << shiftGraphemePropState) - } - - // If we don't know the state, determine it now. - var firstProp int - if state < 0 { - state, firstProp, _ = transitionGraphemeState(state, r) - } else { - firstProp = state >> shiftGraphemePropState - } - width += runeWidth(r, firstProp) - - // Transition until we find a boundary. - for { - var ( - prop int - boundary bool - ) - - r, l := utf8.DecodeRune(b[length:]) - state, prop, boundary = transitionGraphemeState(state&maskGraphemeState, r) - - if boundary { - return b[:length], b[length:], width, state | (prop << shiftGraphemePropState) - } - - if firstProp == prExtendedPictographic { - if r == vs15 { - width = 1 - } else if r == vs16 { - width = 2 - } - } else if firstProp != prRegionalIndicator && firstProp != prL { - width += runeWidth(r, prop) - } - - length += l - if len(b) <= length { - return b, nil, width, grAny | (prop << shiftGraphemePropState) - } - } -} - -// FirstGraphemeClusterInString is like [FirstGraphemeCluster] but its input and -// outputs are strings. -func FirstGraphemeClusterInString(str string, state int) (cluster, rest string, width, newState int) { - // An empty string returns nothing. - if len(str) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRuneInString(str) - if len(str) <= length { // If we're already past the end, there is nothing else to parse. - var prop int - if state < 0 { - prop = propertyGraphemes(r) - } else { - prop = state >> shiftGraphemePropState - } - return str, "", runeWidth(r, prop), grAny | (prop << shiftGraphemePropState) - } - - // If we don't know the state, determine it now. - var firstProp int - if state < 0 { - state, firstProp, _ = transitionGraphemeState(state, r) - } else { - firstProp = state >> shiftGraphemePropState - } - width += runeWidth(r, firstProp) - - // Transition until we find a boundary. - for { - var ( - prop int - boundary bool - ) - - r, l := utf8.DecodeRuneInString(str[length:]) - state, prop, boundary = transitionGraphemeState(state&maskGraphemeState, r) - - if boundary { - return str[:length], str[length:], width, state | (prop << shiftGraphemePropState) - } - - if firstProp == prExtendedPictographic { - if r == vs15 { - width = 1 - } else if r == vs16 { - width = 2 - } - } else if firstProp != prRegionalIndicator && firstProp != prL { - width += runeWidth(r, prop) - } - - length += l - if len(str) <= length { - return str, "", width, grAny | (prop << shiftGraphemePropState) - } - } -} diff --git a/vendor/github.com/rivo/uniseg/graphemeproperties.go b/vendor/github.com/rivo/uniseg/graphemeproperties.go deleted file mode 100644 index 0aff4a6..0000000 --- a/vendor/github.com/rivo/uniseg/graphemeproperties.go +++ /dev/null @@ -1,1915 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// graphemeCodePoints are taken from -// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var graphemeCodePoints = [][3]int{ - {0x0000, 0x0009, prControl}, // Cc [10] .. - {0x000A, 0x000A, prLF}, // Cc - {0x000B, 0x000C, prControl}, // Cc [2] .. - {0x000D, 0x000D, prCR}, // Cc - {0x000E, 0x001F, prControl}, // Cc [18] .. - {0x007F, 0x009F, prControl}, // Cc [33] .. - {0x00A9, 0x00A9, prExtendedPictographic}, // E0.6 [1] (©️) copyright - {0x00AD, 0x00AD, prControl}, // Cf SOFT HYPHEN - {0x00AE, 0x00AE, prExtendedPictographic}, // E0.6 [1] (®️) registered - {0x0300, 0x036F, prExtend}, // Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X - {0x0483, 0x0487, prExtend}, // Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE - {0x0488, 0x0489, prExtend}, // Me [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN - {0x0591, 0x05BD, prExtend}, // Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG - {0x05BF, 0x05BF, prExtend}, // Mn HEBREW POINT RAFE - {0x05C1, 0x05C2, prExtend}, // Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT - {0x05C4, 0x05C5, prExtend}, // Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT - {0x05C7, 0x05C7, prExtend}, // Mn HEBREW POINT QAMATS QATAN - {0x0600, 0x0605, prPrepend}, // Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE - {0x0610, 0x061A, prExtend}, // Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA - {0x061C, 0x061C, prControl}, // Cf ARABIC LETTER MARK - {0x064B, 0x065F, prExtend}, // Mn [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW - {0x0670, 0x0670, prExtend}, // Mn ARABIC LETTER SUPERSCRIPT ALEF - {0x06D6, 0x06DC, prExtend}, // Mn [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN - {0x06DD, 0x06DD, prPrepend}, // Cf ARABIC END OF AYAH - {0x06DF, 0x06E4, prExtend}, // Mn [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA - {0x06E7, 0x06E8, prExtend}, // Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON - {0x06EA, 0x06ED, prExtend}, // Mn [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM - {0x070F, 0x070F, prPrepend}, // Cf SYRIAC ABBREVIATION MARK - {0x0711, 0x0711, prExtend}, // Mn SYRIAC LETTER SUPERSCRIPT ALAPH - {0x0730, 0x074A, prExtend}, // Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH - {0x07A6, 0x07B0, prExtend}, // Mn [11] THAANA ABAFILI..THAANA SUKUN - {0x07EB, 0x07F3, prExtend}, // Mn [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE - {0x07FD, 0x07FD, prExtend}, // Mn NKO DANTAYALAN - {0x0816, 0x0819, prExtend}, // Mn [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH - {0x081B, 0x0823, prExtend}, // Mn [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A - {0x0825, 0x0827, prExtend}, // Mn [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U - {0x0829, 0x082D, prExtend}, // Mn [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA - {0x0859, 0x085B, prExtend}, // Mn [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK - {0x0890, 0x0891, prPrepend}, // Cf [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE - {0x0898, 0x089F, prExtend}, // Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA - {0x08CA, 0x08E1, prExtend}, // Mn [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA - {0x08E2, 0x08E2, prPrepend}, // Cf ARABIC DISPUTED END OF AYAH - {0x08E3, 0x0902, prExtend}, // Mn [32] ARABIC TURNED DAMMA BELOW..DEVANAGARI SIGN ANUSVARA - {0x0903, 0x0903, prSpacingMark}, // Mc DEVANAGARI SIGN VISARGA - {0x093A, 0x093A, prExtend}, // Mn DEVANAGARI VOWEL SIGN OE - {0x093B, 0x093B, prSpacingMark}, // Mc DEVANAGARI VOWEL SIGN OOE - {0x093C, 0x093C, prExtend}, // Mn DEVANAGARI SIGN NUKTA - {0x093E, 0x0940, prSpacingMark}, // Mc [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II - {0x0941, 0x0948, prExtend}, // Mn [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI - {0x0949, 0x094C, prSpacingMark}, // Mc [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU - {0x094D, 0x094D, prExtend}, // Mn DEVANAGARI SIGN VIRAMA - {0x094E, 0x094F, prSpacingMark}, // Mc [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW - {0x0951, 0x0957, prExtend}, // Mn [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE - {0x0962, 0x0963, prExtend}, // Mn [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL - {0x0981, 0x0981, prExtend}, // Mn BENGALI SIGN CANDRABINDU - {0x0982, 0x0983, prSpacingMark}, // Mc [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA - {0x09BC, 0x09BC, prExtend}, // Mn BENGALI SIGN NUKTA - {0x09BE, 0x09BE, prExtend}, // Mc BENGALI VOWEL SIGN AA - {0x09BF, 0x09C0, prSpacingMark}, // Mc [2] BENGALI VOWEL SIGN I..BENGALI VOWEL SIGN II - {0x09C1, 0x09C4, prExtend}, // Mn [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR - {0x09C7, 0x09C8, prSpacingMark}, // Mc [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI - {0x09CB, 0x09CC, prSpacingMark}, // Mc [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU - {0x09CD, 0x09CD, prExtend}, // Mn BENGALI SIGN VIRAMA - {0x09D7, 0x09D7, prExtend}, // Mc BENGALI AU LENGTH MARK - {0x09E2, 0x09E3, prExtend}, // Mn [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL - {0x09FE, 0x09FE, prExtend}, // Mn BENGALI SANDHI MARK - {0x0A01, 0x0A02, prExtend}, // Mn [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI - {0x0A03, 0x0A03, prSpacingMark}, // Mc GURMUKHI SIGN VISARGA - {0x0A3C, 0x0A3C, prExtend}, // Mn GURMUKHI SIGN NUKTA - {0x0A3E, 0x0A40, prSpacingMark}, // Mc [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II - {0x0A41, 0x0A42, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU - {0x0A47, 0x0A48, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI - {0x0A4B, 0x0A4D, prExtend}, // Mn [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA - {0x0A51, 0x0A51, prExtend}, // Mn GURMUKHI SIGN UDAAT - {0x0A70, 0x0A71, prExtend}, // Mn [2] GURMUKHI TIPPI..GURMUKHI ADDAK - {0x0A75, 0x0A75, prExtend}, // Mn GURMUKHI SIGN YAKASH - {0x0A81, 0x0A82, prExtend}, // Mn [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA - {0x0A83, 0x0A83, prSpacingMark}, // Mc GUJARATI SIGN VISARGA - {0x0ABC, 0x0ABC, prExtend}, // Mn GUJARATI SIGN NUKTA - {0x0ABE, 0x0AC0, prSpacingMark}, // Mc [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II - {0x0AC1, 0x0AC5, prExtend}, // Mn [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E - {0x0AC7, 0x0AC8, prExtend}, // Mn [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI - {0x0AC9, 0x0AC9, prSpacingMark}, // Mc GUJARATI VOWEL SIGN CANDRA O - {0x0ACB, 0x0ACC, prSpacingMark}, // Mc [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU - {0x0ACD, 0x0ACD, prExtend}, // Mn GUJARATI SIGN VIRAMA - {0x0AE2, 0x0AE3, prExtend}, // Mn [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL - {0x0AFA, 0x0AFF, prExtend}, // Mn [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE - {0x0B01, 0x0B01, prExtend}, // Mn ORIYA SIGN CANDRABINDU - {0x0B02, 0x0B03, prSpacingMark}, // Mc [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA - {0x0B3C, 0x0B3C, prExtend}, // Mn ORIYA SIGN NUKTA - {0x0B3E, 0x0B3E, prExtend}, // Mc ORIYA VOWEL SIGN AA - {0x0B3F, 0x0B3F, prExtend}, // Mn ORIYA VOWEL SIGN I - {0x0B40, 0x0B40, prSpacingMark}, // Mc ORIYA VOWEL SIGN II - {0x0B41, 0x0B44, prExtend}, // Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR - {0x0B47, 0x0B48, prSpacingMark}, // Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI - {0x0B4B, 0x0B4C, prSpacingMark}, // Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU - {0x0B4D, 0x0B4D, prExtend}, // Mn ORIYA SIGN VIRAMA - {0x0B55, 0x0B56, prExtend}, // Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK - {0x0B57, 0x0B57, prExtend}, // Mc ORIYA AU LENGTH MARK - {0x0B62, 0x0B63, prExtend}, // Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL - {0x0B82, 0x0B82, prExtend}, // Mn TAMIL SIGN ANUSVARA - {0x0BBE, 0x0BBE, prExtend}, // Mc TAMIL VOWEL SIGN AA - {0x0BBF, 0x0BBF, prSpacingMark}, // Mc TAMIL VOWEL SIGN I - {0x0BC0, 0x0BC0, prExtend}, // Mn TAMIL VOWEL SIGN II - {0x0BC1, 0x0BC2, prSpacingMark}, // Mc [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU - {0x0BC6, 0x0BC8, prSpacingMark}, // Mc [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI - {0x0BCA, 0x0BCC, prSpacingMark}, // Mc [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU - {0x0BCD, 0x0BCD, prExtend}, // Mn TAMIL SIGN VIRAMA - {0x0BD7, 0x0BD7, prExtend}, // Mc TAMIL AU LENGTH MARK - {0x0C00, 0x0C00, prExtend}, // Mn TELUGU SIGN COMBINING CANDRABINDU ABOVE - {0x0C01, 0x0C03, prSpacingMark}, // Mc [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA - {0x0C04, 0x0C04, prExtend}, // Mn TELUGU SIGN COMBINING ANUSVARA ABOVE - {0x0C3C, 0x0C3C, prExtend}, // Mn TELUGU SIGN NUKTA - {0x0C3E, 0x0C40, prExtend}, // Mn [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II - {0x0C41, 0x0C44, prSpacingMark}, // Mc [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR - {0x0C46, 0x0C48, prExtend}, // Mn [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI - {0x0C4A, 0x0C4D, prExtend}, // Mn [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA - {0x0C55, 0x0C56, prExtend}, // Mn [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK - {0x0C62, 0x0C63, prExtend}, // Mn [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL - {0x0C81, 0x0C81, prExtend}, // Mn KANNADA SIGN CANDRABINDU - {0x0C82, 0x0C83, prSpacingMark}, // Mc [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA - {0x0CBC, 0x0CBC, prExtend}, // Mn KANNADA SIGN NUKTA - {0x0CBE, 0x0CBE, prSpacingMark}, // Mc KANNADA VOWEL SIGN AA - {0x0CBF, 0x0CBF, prExtend}, // Mn KANNADA VOWEL SIGN I - {0x0CC0, 0x0CC1, prSpacingMark}, // Mc [2] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN U - {0x0CC2, 0x0CC2, prExtend}, // Mc KANNADA VOWEL SIGN UU - {0x0CC3, 0x0CC4, prSpacingMark}, // Mc [2] KANNADA VOWEL SIGN VOCALIC R..KANNADA VOWEL SIGN VOCALIC RR - {0x0CC6, 0x0CC6, prExtend}, // Mn KANNADA VOWEL SIGN E - {0x0CC7, 0x0CC8, prSpacingMark}, // Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI - {0x0CCA, 0x0CCB, prSpacingMark}, // Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO - {0x0CCC, 0x0CCD, prExtend}, // Mn [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA - {0x0CD5, 0x0CD6, prExtend}, // Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK - {0x0CE2, 0x0CE3, prExtend}, // Mn [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL - {0x0CF3, 0x0CF3, prSpacingMark}, // Mc KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT - {0x0D00, 0x0D01, prExtend}, // Mn [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU - {0x0D02, 0x0D03, prSpacingMark}, // Mc [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA - {0x0D3B, 0x0D3C, prExtend}, // Mn [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA - {0x0D3E, 0x0D3E, prExtend}, // Mc MALAYALAM VOWEL SIGN AA - {0x0D3F, 0x0D40, prSpacingMark}, // Mc [2] MALAYALAM VOWEL SIGN I..MALAYALAM VOWEL SIGN II - {0x0D41, 0x0D44, prExtend}, // Mn [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR - {0x0D46, 0x0D48, prSpacingMark}, // Mc [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI - {0x0D4A, 0x0D4C, prSpacingMark}, // Mc [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU - {0x0D4D, 0x0D4D, prExtend}, // Mn MALAYALAM SIGN VIRAMA - {0x0D4E, 0x0D4E, prPrepend}, // Lo MALAYALAM LETTER DOT REPH - {0x0D57, 0x0D57, prExtend}, // Mc MALAYALAM AU LENGTH MARK - {0x0D62, 0x0D63, prExtend}, // Mn [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL - {0x0D81, 0x0D81, prExtend}, // Mn SINHALA SIGN CANDRABINDU - {0x0D82, 0x0D83, prSpacingMark}, // Mc [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA - {0x0DCA, 0x0DCA, prExtend}, // Mn SINHALA SIGN AL-LAKUNA - {0x0DCF, 0x0DCF, prExtend}, // Mc SINHALA VOWEL SIGN AELA-PILLA - {0x0DD0, 0x0DD1, prSpacingMark}, // Mc [2] SINHALA VOWEL SIGN KETTI AEDA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA - {0x0DD2, 0x0DD4, prExtend}, // Mn [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA - {0x0DD6, 0x0DD6, prExtend}, // Mn SINHALA VOWEL SIGN DIGA PAA-PILLA - {0x0DD8, 0x0DDE, prSpacingMark}, // Mc [7] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA - {0x0DDF, 0x0DDF, prExtend}, // Mc SINHALA VOWEL SIGN GAYANUKITTA - {0x0DF2, 0x0DF3, prSpacingMark}, // Mc [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA - {0x0E31, 0x0E31, prExtend}, // Mn THAI CHARACTER MAI HAN-AKAT - {0x0E33, 0x0E33, prSpacingMark}, // Lo THAI CHARACTER SARA AM - {0x0E34, 0x0E3A, prExtend}, // Mn [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU - {0x0E47, 0x0E4E, prExtend}, // Mn [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN - {0x0EB1, 0x0EB1, prExtend}, // Mn LAO VOWEL SIGN MAI KAN - {0x0EB3, 0x0EB3, prSpacingMark}, // Lo LAO VOWEL SIGN AM - {0x0EB4, 0x0EBC, prExtend}, // Mn [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO - {0x0EC8, 0x0ECE, prExtend}, // Mn [7] LAO TONE MAI EK..LAO YAMAKKAN - {0x0F18, 0x0F19, prExtend}, // Mn [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS - {0x0F35, 0x0F35, prExtend}, // Mn TIBETAN MARK NGAS BZUNG NYI ZLA - {0x0F37, 0x0F37, prExtend}, // Mn TIBETAN MARK NGAS BZUNG SGOR RTAGS - {0x0F39, 0x0F39, prExtend}, // Mn TIBETAN MARK TSA -PHRU - {0x0F3E, 0x0F3F, prSpacingMark}, // Mc [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES - {0x0F71, 0x0F7E, prExtend}, // Mn [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO - {0x0F7F, 0x0F7F, prSpacingMark}, // Mc TIBETAN SIGN RNAM BCAD - {0x0F80, 0x0F84, prExtend}, // Mn [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA - {0x0F86, 0x0F87, prExtend}, // Mn [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS - {0x0F8D, 0x0F97, prExtend}, // Mn [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA - {0x0F99, 0x0FBC, prExtend}, // Mn [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA - {0x0FC6, 0x0FC6, prExtend}, // Mn TIBETAN SYMBOL PADMA GDAN - {0x102D, 0x1030, prExtend}, // Mn [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU - {0x1031, 0x1031, prSpacingMark}, // Mc MYANMAR VOWEL SIGN E - {0x1032, 0x1037, prExtend}, // Mn [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW - {0x1039, 0x103A, prExtend}, // Mn [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT - {0x103B, 0x103C, prSpacingMark}, // Mc [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA - {0x103D, 0x103E, prExtend}, // Mn [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA - {0x1056, 0x1057, prSpacingMark}, // Mc [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR - {0x1058, 0x1059, prExtend}, // Mn [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL - {0x105E, 0x1060, prExtend}, // Mn [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA - {0x1071, 0x1074, prExtend}, // Mn [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE - {0x1082, 0x1082, prExtend}, // Mn MYANMAR CONSONANT SIGN SHAN MEDIAL WA - {0x1084, 0x1084, prSpacingMark}, // Mc MYANMAR VOWEL SIGN SHAN E - {0x1085, 0x1086, prExtend}, // Mn [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y - {0x108D, 0x108D, prExtend}, // Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE - {0x109D, 0x109D, prExtend}, // Mn MYANMAR VOWEL SIGN AITON AI - {0x1100, 0x115F, prL}, // Lo [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER - {0x1160, 0x11A7, prV}, // Lo [72] HANGUL JUNGSEONG FILLER..HANGUL JUNGSEONG O-YAE - {0x11A8, 0x11FF, prT}, // Lo [88] HANGUL JONGSEONG KIYEOK..HANGUL JONGSEONG SSANGNIEUN - {0x135D, 0x135F, prExtend}, // Mn [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK - {0x1712, 0x1714, prExtend}, // Mn [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA - {0x1715, 0x1715, prSpacingMark}, // Mc TAGALOG SIGN PAMUDPOD - {0x1732, 0x1733, prExtend}, // Mn [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U - {0x1734, 0x1734, prSpacingMark}, // Mc HANUNOO SIGN PAMUDPOD - {0x1752, 0x1753, prExtend}, // Mn [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U - {0x1772, 0x1773, prExtend}, // Mn [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U - {0x17B4, 0x17B5, prExtend}, // Mn [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA - {0x17B6, 0x17B6, prSpacingMark}, // Mc KHMER VOWEL SIGN AA - {0x17B7, 0x17BD, prExtend}, // Mn [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA - {0x17BE, 0x17C5, prSpacingMark}, // Mc [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU - {0x17C6, 0x17C6, prExtend}, // Mn KHMER SIGN NIKAHIT - {0x17C7, 0x17C8, prSpacingMark}, // Mc [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU - {0x17C9, 0x17D3, prExtend}, // Mn [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT - {0x17DD, 0x17DD, prExtend}, // Mn KHMER SIGN ATTHACAN - {0x180B, 0x180D, prExtend}, // Mn [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE - {0x180E, 0x180E, prControl}, // Cf MONGOLIAN VOWEL SEPARATOR - {0x180F, 0x180F, prExtend}, // Mn MONGOLIAN FREE VARIATION SELECTOR FOUR - {0x1885, 0x1886, prExtend}, // Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA - {0x18A9, 0x18A9, prExtend}, // Mn MONGOLIAN LETTER ALI GALI DAGALGA - {0x1920, 0x1922, prExtend}, // Mn [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U - {0x1923, 0x1926, prSpacingMark}, // Mc [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU - {0x1927, 0x1928, prExtend}, // Mn [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O - {0x1929, 0x192B, prSpacingMark}, // Mc [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA - {0x1930, 0x1931, prSpacingMark}, // Mc [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA - {0x1932, 0x1932, prExtend}, // Mn LIMBU SMALL LETTER ANUSVARA - {0x1933, 0x1938, prSpacingMark}, // Mc [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA - {0x1939, 0x193B, prExtend}, // Mn [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I - {0x1A17, 0x1A18, prExtend}, // Mn [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U - {0x1A19, 0x1A1A, prSpacingMark}, // Mc [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O - {0x1A1B, 0x1A1B, prExtend}, // Mn BUGINESE VOWEL SIGN AE - {0x1A55, 0x1A55, prSpacingMark}, // Mc TAI THAM CONSONANT SIGN MEDIAL RA - {0x1A56, 0x1A56, prExtend}, // Mn TAI THAM CONSONANT SIGN MEDIAL LA - {0x1A57, 0x1A57, prSpacingMark}, // Mc TAI THAM CONSONANT SIGN LA TANG LAI - {0x1A58, 0x1A5E, prExtend}, // Mn [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA - {0x1A60, 0x1A60, prExtend}, // Mn TAI THAM SIGN SAKOT - {0x1A62, 0x1A62, prExtend}, // Mn TAI THAM VOWEL SIGN MAI SAT - {0x1A65, 0x1A6C, prExtend}, // Mn [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW - {0x1A6D, 0x1A72, prSpacingMark}, // Mc [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI - {0x1A73, 0x1A7C, prExtend}, // Mn [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN - {0x1A7F, 0x1A7F, prExtend}, // Mn TAI THAM COMBINING CRYPTOGRAMMIC DOT - {0x1AB0, 0x1ABD, prExtend}, // Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW - {0x1ABE, 0x1ABE, prExtend}, // Me COMBINING PARENTHESES OVERLAY - {0x1ABF, 0x1ACE, prExtend}, // Mn [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T - {0x1B00, 0x1B03, prExtend}, // Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG - {0x1B04, 0x1B04, prSpacingMark}, // Mc BALINESE SIGN BISAH - {0x1B34, 0x1B34, prExtend}, // Mn BALINESE SIGN REREKAN - {0x1B35, 0x1B35, prExtend}, // Mc BALINESE VOWEL SIGN TEDUNG - {0x1B36, 0x1B3A, prExtend}, // Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA - {0x1B3B, 0x1B3B, prSpacingMark}, // Mc BALINESE VOWEL SIGN RA REPA TEDUNG - {0x1B3C, 0x1B3C, prExtend}, // Mn BALINESE VOWEL SIGN LA LENGA - {0x1B3D, 0x1B41, prSpacingMark}, // Mc [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG - {0x1B42, 0x1B42, prExtend}, // Mn BALINESE VOWEL SIGN PEPET - {0x1B43, 0x1B44, prSpacingMark}, // Mc [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG - {0x1B6B, 0x1B73, prExtend}, // Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG - {0x1B80, 0x1B81, prExtend}, // Mn [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR - {0x1B82, 0x1B82, prSpacingMark}, // Mc SUNDANESE SIGN PANGWISAD - {0x1BA1, 0x1BA1, prSpacingMark}, // Mc SUNDANESE CONSONANT SIGN PAMINGKAL - {0x1BA2, 0x1BA5, prExtend}, // Mn [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU - {0x1BA6, 0x1BA7, prSpacingMark}, // Mc [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG - {0x1BA8, 0x1BA9, prExtend}, // Mn [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG - {0x1BAA, 0x1BAA, prSpacingMark}, // Mc SUNDANESE SIGN PAMAAEH - {0x1BAB, 0x1BAD, prExtend}, // Mn [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA - {0x1BE6, 0x1BE6, prExtend}, // Mn BATAK SIGN TOMPI - {0x1BE7, 0x1BE7, prSpacingMark}, // Mc BATAK VOWEL SIGN E - {0x1BE8, 0x1BE9, prExtend}, // Mn [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE - {0x1BEA, 0x1BEC, prSpacingMark}, // Mc [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O - {0x1BED, 0x1BED, prExtend}, // Mn BATAK VOWEL SIGN KARO O - {0x1BEE, 0x1BEE, prSpacingMark}, // Mc BATAK VOWEL SIGN U - {0x1BEF, 0x1BF1, prExtend}, // Mn [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H - {0x1BF2, 0x1BF3, prSpacingMark}, // Mc [2] BATAK PANGOLAT..BATAK PANONGONAN - {0x1C24, 0x1C2B, prSpacingMark}, // Mc [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU - {0x1C2C, 0x1C33, prExtend}, // Mn [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T - {0x1C34, 0x1C35, prSpacingMark}, // Mc [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG - {0x1C36, 0x1C37, prExtend}, // Mn [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA - {0x1CD0, 0x1CD2, prExtend}, // Mn [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA - {0x1CD4, 0x1CE0, prExtend}, // Mn [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA - {0x1CE1, 0x1CE1, prSpacingMark}, // Mc VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA - {0x1CE2, 0x1CE8, prExtend}, // Mn [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL - {0x1CED, 0x1CED, prExtend}, // Mn VEDIC SIGN TIRYAK - {0x1CF4, 0x1CF4, prExtend}, // Mn VEDIC TONE CANDRA ABOVE - {0x1CF7, 0x1CF7, prSpacingMark}, // Mc VEDIC SIGN ATIKRAMA - {0x1CF8, 0x1CF9, prExtend}, // Mn [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE - {0x1DC0, 0x1DFF, prExtend}, // Mn [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW - {0x200B, 0x200B, prControl}, // Cf ZERO WIDTH SPACE - {0x200C, 0x200C, prExtend}, // Cf ZERO WIDTH NON-JOINER - {0x200D, 0x200D, prZWJ}, // Cf ZERO WIDTH JOINER - {0x200E, 0x200F, prControl}, // Cf [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK - {0x2028, 0x2028, prControl}, // Zl LINE SEPARATOR - {0x2029, 0x2029, prControl}, // Zp PARAGRAPH SEPARATOR - {0x202A, 0x202E, prControl}, // Cf [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE - {0x203C, 0x203C, prExtendedPictographic}, // E0.6 [1] (‼️) double exclamation mark - {0x2049, 0x2049, prExtendedPictographic}, // E0.6 [1] (⁉️) exclamation question mark - {0x2060, 0x2064, prControl}, // Cf [5] WORD JOINER..INVISIBLE PLUS - {0x2065, 0x2065, prControl}, // Cn - {0x2066, 0x206F, prControl}, // Cf [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES - {0x20D0, 0x20DC, prExtend}, // Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE - {0x20DD, 0x20E0, prExtend}, // Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH - {0x20E1, 0x20E1, prExtend}, // Mn COMBINING LEFT RIGHT ARROW ABOVE - {0x20E2, 0x20E4, prExtend}, // Me [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE - {0x20E5, 0x20F0, prExtend}, // Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE - {0x2122, 0x2122, prExtendedPictographic}, // E0.6 [1] (™️) trade mark - {0x2139, 0x2139, prExtendedPictographic}, // E0.6 [1] (ℹ️) information - {0x2194, 0x2199, prExtendedPictographic}, // E0.6 [6] (↔️..↙️) left-right arrow..down-left arrow - {0x21A9, 0x21AA, prExtendedPictographic}, // E0.6 [2] (↩️..↪️) right arrow curving left..left arrow curving right - {0x231A, 0x231B, prExtendedPictographic}, // E0.6 [2] (⌚..⌛) watch..hourglass done - {0x2328, 0x2328, prExtendedPictographic}, // E1.0 [1] (⌨️) keyboard - {0x2388, 0x2388, prExtendedPictographic}, // E0.0 [1] (⎈) HELM SYMBOL - {0x23CF, 0x23CF, prExtendedPictographic}, // E1.0 [1] (⏏️) eject button - {0x23E9, 0x23EC, prExtendedPictographic}, // E0.6 [4] (⏩..⏬) fast-forward button..fast down button - {0x23ED, 0x23EE, prExtendedPictographic}, // E0.7 [2] (⏭️..⏮️) next track button..last track button - {0x23EF, 0x23EF, prExtendedPictographic}, // E1.0 [1] (⏯️) play or pause button - {0x23F0, 0x23F0, prExtendedPictographic}, // E0.6 [1] (⏰) alarm clock - {0x23F1, 0x23F2, prExtendedPictographic}, // E1.0 [2] (⏱️..⏲️) stopwatch..timer clock - {0x23F3, 0x23F3, prExtendedPictographic}, // E0.6 [1] (⏳) hourglass not done - {0x23F8, 0x23FA, prExtendedPictographic}, // E0.7 [3] (⏸️..⏺️) pause button..record button - {0x24C2, 0x24C2, prExtendedPictographic}, // E0.6 [1] (Ⓜ️) circled M - {0x25AA, 0x25AB, prExtendedPictographic}, // E0.6 [2] (▪️..▫️) black small square..white small square - {0x25B6, 0x25B6, prExtendedPictographic}, // E0.6 [1] (▶️) play button - {0x25C0, 0x25C0, prExtendedPictographic}, // E0.6 [1] (◀️) reverse button - {0x25FB, 0x25FE, prExtendedPictographic}, // E0.6 [4] (◻️..◾) white medium square..black medium-small square - {0x2600, 0x2601, prExtendedPictographic}, // E0.6 [2] (☀️..☁️) sun..cloud - {0x2602, 0x2603, prExtendedPictographic}, // E0.7 [2] (☂️..☃️) umbrella..snowman - {0x2604, 0x2604, prExtendedPictographic}, // E1.0 [1] (☄️) comet - {0x2605, 0x2605, prExtendedPictographic}, // E0.0 [1] (★) BLACK STAR - {0x2607, 0x260D, prExtendedPictographic}, // E0.0 [7] (☇..☍) LIGHTNING..OPPOSITION - {0x260E, 0x260E, prExtendedPictographic}, // E0.6 [1] (☎️) telephone - {0x260F, 0x2610, prExtendedPictographic}, // E0.0 [2] (☏..☐) WHITE TELEPHONE..BALLOT BOX - {0x2611, 0x2611, prExtendedPictographic}, // E0.6 [1] (☑️) check box with check - {0x2612, 0x2612, prExtendedPictographic}, // E0.0 [1] (☒) BALLOT BOX WITH X - {0x2614, 0x2615, prExtendedPictographic}, // E0.6 [2] (☔..☕) umbrella with rain drops..hot beverage - {0x2616, 0x2617, prExtendedPictographic}, // E0.0 [2] (☖..☗) WHITE SHOGI PIECE..BLACK SHOGI PIECE - {0x2618, 0x2618, prExtendedPictographic}, // E1.0 [1] (☘️) shamrock - {0x2619, 0x261C, prExtendedPictographic}, // E0.0 [4] (☙..☜) REVERSED ROTATED FLORAL HEART BULLET..WHITE LEFT POINTING INDEX - {0x261D, 0x261D, prExtendedPictographic}, // E0.6 [1] (☝️) index pointing up - {0x261E, 0x261F, prExtendedPictographic}, // E0.0 [2] (☞..☟) WHITE RIGHT POINTING INDEX..WHITE DOWN POINTING INDEX - {0x2620, 0x2620, prExtendedPictographic}, // E1.0 [1] (☠️) skull and crossbones - {0x2621, 0x2621, prExtendedPictographic}, // E0.0 [1] (☡) CAUTION SIGN - {0x2622, 0x2623, prExtendedPictographic}, // E1.0 [2] (☢️..☣️) radioactive..biohazard - {0x2624, 0x2625, prExtendedPictographic}, // E0.0 [2] (☤..☥) CADUCEUS..ANKH - {0x2626, 0x2626, prExtendedPictographic}, // E1.0 [1] (☦️) orthodox cross - {0x2627, 0x2629, prExtendedPictographic}, // E0.0 [3] (☧..☩) CHI RHO..CROSS OF JERUSALEM - {0x262A, 0x262A, prExtendedPictographic}, // E0.7 [1] (☪️) star and crescent - {0x262B, 0x262D, prExtendedPictographic}, // E0.0 [3] (☫..☭) FARSI SYMBOL..HAMMER AND SICKLE - {0x262E, 0x262E, prExtendedPictographic}, // E1.0 [1] (☮️) peace symbol - {0x262F, 0x262F, prExtendedPictographic}, // E0.7 [1] (☯️) yin yang - {0x2630, 0x2637, prExtendedPictographic}, // E0.0 [8] (☰..☷) TRIGRAM FOR HEAVEN..TRIGRAM FOR EARTH - {0x2638, 0x2639, prExtendedPictographic}, // E0.7 [2] (☸️..☹️) wheel of dharma..frowning face - {0x263A, 0x263A, prExtendedPictographic}, // E0.6 [1] (☺️) smiling face - {0x263B, 0x263F, prExtendedPictographic}, // E0.0 [5] (☻..☿) BLACK SMILING FACE..MERCURY - {0x2640, 0x2640, prExtendedPictographic}, // E4.0 [1] (♀️) female sign - {0x2641, 0x2641, prExtendedPictographic}, // E0.0 [1] (♁) EARTH - {0x2642, 0x2642, prExtendedPictographic}, // E4.0 [1] (♂️) male sign - {0x2643, 0x2647, prExtendedPictographic}, // E0.0 [5] (♃..♇) JUPITER..PLUTO - {0x2648, 0x2653, prExtendedPictographic}, // E0.6 [12] (♈..♓) Aries..Pisces - {0x2654, 0x265E, prExtendedPictographic}, // E0.0 [11] (♔..♞) WHITE CHESS KING..BLACK CHESS KNIGHT - {0x265F, 0x265F, prExtendedPictographic}, // E11.0 [1] (♟️) chess pawn - {0x2660, 0x2660, prExtendedPictographic}, // E0.6 [1] (♠️) spade suit - {0x2661, 0x2662, prExtendedPictographic}, // E0.0 [2] (♡..♢) WHITE HEART SUIT..WHITE DIAMOND SUIT - {0x2663, 0x2663, prExtendedPictographic}, // E0.6 [1] (♣️) club suit - {0x2664, 0x2664, prExtendedPictographic}, // E0.0 [1] (♤) WHITE SPADE SUIT - {0x2665, 0x2666, prExtendedPictographic}, // E0.6 [2] (♥️..♦️) heart suit..diamond suit - {0x2667, 0x2667, prExtendedPictographic}, // E0.0 [1] (♧) WHITE CLUB SUIT - {0x2668, 0x2668, prExtendedPictographic}, // E0.6 [1] (♨️) hot springs - {0x2669, 0x267A, prExtendedPictographic}, // E0.0 [18] (♩..♺) QUARTER NOTE..RECYCLING SYMBOL FOR GENERIC MATERIALS - {0x267B, 0x267B, prExtendedPictographic}, // E0.6 [1] (♻️) recycling symbol - {0x267C, 0x267D, prExtendedPictographic}, // E0.0 [2] (♼..♽) RECYCLED PAPER SYMBOL..PARTIALLY-RECYCLED PAPER SYMBOL - {0x267E, 0x267E, prExtendedPictographic}, // E11.0 [1] (♾️) infinity - {0x267F, 0x267F, prExtendedPictographic}, // E0.6 [1] (♿) wheelchair symbol - {0x2680, 0x2685, prExtendedPictographic}, // E0.0 [6] (⚀..⚅) DIE FACE-1..DIE FACE-6 - {0x2690, 0x2691, prExtendedPictographic}, // E0.0 [2] (⚐..⚑) WHITE FLAG..BLACK FLAG - {0x2692, 0x2692, prExtendedPictographic}, // E1.0 [1] (⚒️) hammer and pick - {0x2693, 0x2693, prExtendedPictographic}, // E0.6 [1] (⚓) anchor - {0x2694, 0x2694, prExtendedPictographic}, // E1.0 [1] (⚔️) crossed swords - {0x2695, 0x2695, prExtendedPictographic}, // E4.0 [1] (⚕️) medical symbol - {0x2696, 0x2697, prExtendedPictographic}, // E1.0 [2] (⚖️..⚗️) balance scale..alembic - {0x2698, 0x2698, prExtendedPictographic}, // E0.0 [1] (⚘) FLOWER - {0x2699, 0x2699, prExtendedPictographic}, // E1.0 [1] (⚙️) gear - {0x269A, 0x269A, prExtendedPictographic}, // E0.0 [1] (⚚) STAFF OF HERMES - {0x269B, 0x269C, prExtendedPictographic}, // E1.0 [2] (⚛️..⚜️) atom symbol..fleur-de-lis - {0x269D, 0x269F, prExtendedPictographic}, // E0.0 [3] (⚝..⚟) OUTLINED WHITE STAR..THREE LINES CONVERGING LEFT - {0x26A0, 0x26A1, prExtendedPictographic}, // E0.6 [2] (⚠️..⚡) warning..high voltage - {0x26A2, 0x26A6, prExtendedPictographic}, // E0.0 [5] (⚢..⚦) DOUBLED FEMALE SIGN..MALE WITH STROKE SIGN - {0x26A7, 0x26A7, prExtendedPictographic}, // E13.0 [1] (⚧️) transgender symbol - {0x26A8, 0x26A9, prExtendedPictographic}, // E0.0 [2] (⚨..⚩) VERTICAL MALE WITH STROKE SIGN..HORIZONTAL MALE WITH STROKE SIGN - {0x26AA, 0x26AB, prExtendedPictographic}, // E0.6 [2] (⚪..⚫) white circle..black circle - {0x26AC, 0x26AF, prExtendedPictographic}, // E0.0 [4] (⚬..⚯) MEDIUM SMALL WHITE CIRCLE..UNMARRIED PARTNERSHIP SYMBOL - {0x26B0, 0x26B1, prExtendedPictographic}, // E1.0 [2] (⚰️..⚱️) coffin..funeral urn - {0x26B2, 0x26BC, prExtendedPictographic}, // E0.0 [11] (⚲..⚼) NEUTER..SESQUIQUADRATE - {0x26BD, 0x26BE, prExtendedPictographic}, // E0.6 [2] (⚽..⚾) soccer ball..baseball - {0x26BF, 0x26C3, prExtendedPictographic}, // E0.0 [5] (⚿..⛃) SQUARED KEY..BLACK DRAUGHTS KING - {0x26C4, 0x26C5, prExtendedPictographic}, // E0.6 [2] (⛄..⛅) snowman without snow..sun behind cloud - {0x26C6, 0x26C7, prExtendedPictographic}, // E0.0 [2] (⛆..⛇) RAIN..BLACK SNOWMAN - {0x26C8, 0x26C8, prExtendedPictographic}, // E0.7 [1] (⛈️) cloud with lightning and rain - {0x26C9, 0x26CD, prExtendedPictographic}, // E0.0 [5] (⛉..⛍) TURNED WHITE SHOGI PIECE..DISABLED CAR - {0x26CE, 0x26CE, prExtendedPictographic}, // E0.6 [1] (⛎) Ophiuchus - {0x26CF, 0x26CF, prExtendedPictographic}, // E0.7 [1] (⛏️) pick - {0x26D0, 0x26D0, prExtendedPictographic}, // E0.0 [1] (⛐) CAR SLIDING - {0x26D1, 0x26D1, prExtendedPictographic}, // E0.7 [1] (⛑️) rescue worker’s helmet - {0x26D2, 0x26D2, prExtendedPictographic}, // E0.0 [1] (⛒) CIRCLED CROSSING LANES - {0x26D3, 0x26D3, prExtendedPictographic}, // E0.7 [1] (⛓️) chains - {0x26D4, 0x26D4, prExtendedPictographic}, // E0.6 [1] (⛔) no entry - {0x26D5, 0x26E8, prExtendedPictographic}, // E0.0 [20] (⛕..⛨) ALTERNATE ONE-WAY LEFT WAY TRAFFIC..BLACK CROSS ON SHIELD - {0x26E9, 0x26E9, prExtendedPictographic}, // E0.7 [1] (⛩️) shinto shrine - {0x26EA, 0x26EA, prExtendedPictographic}, // E0.6 [1] (⛪) church - {0x26EB, 0x26EF, prExtendedPictographic}, // E0.0 [5] (⛫..⛯) CASTLE..MAP SYMBOL FOR LIGHTHOUSE - {0x26F0, 0x26F1, prExtendedPictographic}, // E0.7 [2] (⛰️..⛱️) mountain..umbrella on ground - {0x26F2, 0x26F3, prExtendedPictographic}, // E0.6 [2] (⛲..⛳) fountain..flag in hole - {0x26F4, 0x26F4, prExtendedPictographic}, // E0.7 [1] (⛴️) ferry - {0x26F5, 0x26F5, prExtendedPictographic}, // E0.6 [1] (⛵) sailboat - {0x26F6, 0x26F6, prExtendedPictographic}, // E0.0 [1] (⛶) SQUARE FOUR CORNERS - {0x26F7, 0x26F9, prExtendedPictographic}, // E0.7 [3] (⛷️..⛹️) skier..person bouncing ball - {0x26FA, 0x26FA, prExtendedPictographic}, // E0.6 [1] (⛺) tent - {0x26FB, 0x26FC, prExtendedPictographic}, // E0.0 [2] (⛻..⛼) JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL - {0x26FD, 0x26FD, prExtendedPictographic}, // E0.6 [1] (⛽) fuel pump - {0x26FE, 0x2701, prExtendedPictographic}, // E0.0 [4] (⛾..✁) CUP ON BLACK SQUARE..UPPER BLADE SCISSORS - {0x2702, 0x2702, prExtendedPictographic}, // E0.6 [1] (✂️) scissors - {0x2703, 0x2704, prExtendedPictographic}, // E0.0 [2] (✃..✄) LOWER BLADE SCISSORS..WHITE SCISSORS - {0x2705, 0x2705, prExtendedPictographic}, // E0.6 [1] (✅) check mark button - {0x2708, 0x270C, prExtendedPictographic}, // E0.6 [5] (✈️..✌️) airplane..victory hand - {0x270D, 0x270D, prExtendedPictographic}, // E0.7 [1] (✍️) writing hand - {0x270E, 0x270E, prExtendedPictographic}, // E0.0 [1] (✎) LOWER RIGHT PENCIL - {0x270F, 0x270F, prExtendedPictographic}, // E0.6 [1] (✏️) pencil - {0x2710, 0x2711, prExtendedPictographic}, // E0.0 [2] (✐..✑) UPPER RIGHT PENCIL..WHITE NIB - {0x2712, 0x2712, prExtendedPictographic}, // E0.6 [1] (✒️) black nib - {0x2714, 0x2714, prExtendedPictographic}, // E0.6 [1] (✔️) check mark - {0x2716, 0x2716, prExtendedPictographic}, // E0.6 [1] (✖️) multiply - {0x271D, 0x271D, prExtendedPictographic}, // E0.7 [1] (✝️) latin cross - {0x2721, 0x2721, prExtendedPictographic}, // E0.7 [1] (✡️) star of David - {0x2728, 0x2728, prExtendedPictographic}, // E0.6 [1] (✨) sparkles - {0x2733, 0x2734, prExtendedPictographic}, // E0.6 [2] (✳️..✴️) eight-spoked asterisk..eight-pointed star - {0x2744, 0x2744, prExtendedPictographic}, // E0.6 [1] (❄️) snowflake - {0x2747, 0x2747, prExtendedPictographic}, // E0.6 [1] (❇️) sparkle - {0x274C, 0x274C, prExtendedPictographic}, // E0.6 [1] (❌) cross mark - {0x274E, 0x274E, prExtendedPictographic}, // E0.6 [1] (❎) cross mark button - {0x2753, 0x2755, prExtendedPictographic}, // E0.6 [3] (❓..❕) red question mark..white exclamation mark - {0x2757, 0x2757, prExtendedPictographic}, // E0.6 [1] (❗) red exclamation mark - {0x2763, 0x2763, prExtendedPictographic}, // E1.0 [1] (❣️) heart exclamation - {0x2764, 0x2764, prExtendedPictographic}, // E0.6 [1] (❤️) red heart - {0x2765, 0x2767, prExtendedPictographic}, // E0.0 [3] (❥..❧) ROTATED HEAVY BLACK HEART BULLET..ROTATED FLORAL HEART BULLET - {0x2795, 0x2797, prExtendedPictographic}, // E0.6 [3] (➕..➗) plus..divide - {0x27A1, 0x27A1, prExtendedPictographic}, // E0.6 [1] (➡️) right arrow - {0x27B0, 0x27B0, prExtendedPictographic}, // E0.6 [1] (➰) curly loop - {0x27BF, 0x27BF, prExtendedPictographic}, // E1.0 [1] (➿) double curly loop - {0x2934, 0x2935, prExtendedPictographic}, // E0.6 [2] (⤴️..⤵️) right arrow curving up..right arrow curving down - {0x2B05, 0x2B07, prExtendedPictographic}, // E0.6 [3] (⬅️..⬇️) left arrow..down arrow - {0x2B1B, 0x2B1C, prExtendedPictographic}, // E0.6 [2] (⬛..⬜) black large square..white large square - {0x2B50, 0x2B50, prExtendedPictographic}, // E0.6 [1] (⭐) star - {0x2B55, 0x2B55, prExtendedPictographic}, // E0.6 [1] (⭕) hollow red circle - {0x2CEF, 0x2CF1, prExtend}, // Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS - {0x2D7F, 0x2D7F, prExtend}, // Mn TIFINAGH CONSONANT JOINER - {0x2DE0, 0x2DFF, prExtend}, // Mn [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS - {0x302A, 0x302D, prExtend}, // Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK - {0x302E, 0x302F, prExtend}, // Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK - {0x3030, 0x3030, prExtendedPictographic}, // E0.6 [1] (〰️) wavy dash - {0x303D, 0x303D, prExtendedPictographic}, // E0.6 [1] (〽️) part alternation mark - {0x3099, 0x309A, prExtend}, // Mn [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x3297, 0x3297, prExtendedPictographic}, // E0.6 [1] (㊗️) Japanese “congratulations” button - {0x3299, 0x3299, prExtendedPictographic}, // E0.6 [1] (㊙️) Japanese “secret” button - {0xA66F, 0xA66F, prExtend}, // Mn COMBINING CYRILLIC VZMET - {0xA670, 0xA672, prExtend}, // Me [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN - {0xA674, 0xA67D, prExtend}, // Mn [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK - {0xA69E, 0xA69F, prExtend}, // Mn [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E - {0xA6F0, 0xA6F1, prExtend}, // Mn [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS - {0xA802, 0xA802, prExtend}, // Mn SYLOTI NAGRI SIGN DVISVARA - {0xA806, 0xA806, prExtend}, // Mn SYLOTI NAGRI SIGN HASANTA - {0xA80B, 0xA80B, prExtend}, // Mn SYLOTI NAGRI SIGN ANUSVARA - {0xA823, 0xA824, prSpacingMark}, // Mc [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I - {0xA825, 0xA826, prExtend}, // Mn [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E - {0xA827, 0xA827, prSpacingMark}, // Mc SYLOTI NAGRI VOWEL SIGN OO - {0xA82C, 0xA82C, prExtend}, // Mn SYLOTI NAGRI SIGN ALTERNATE HASANTA - {0xA880, 0xA881, prSpacingMark}, // Mc [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA - {0xA8B4, 0xA8C3, prSpacingMark}, // Mc [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU - {0xA8C4, 0xA8C5, prExtend}, // Mn [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU - {0xA8E0, 0xA8F1, prExtend}, // Mn [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA - {0xA8FF, 0xA8FF, prExtend}, // Mn DEVANAGARI VOWEL SIGN AY - {0xA926, 0xA92D, prExtend}, // Mn [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU - {0xA947, 0xA951, prExtend}, // Mn [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R - {0xA952, 0xA953, prSpacingMark}, // Mc [2] REJANG CONSONANT SIGN H..REJANG VIRAMA - {0xA960, 0xA97C, prL}, // Lo [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH - {0xA980, 0xA982, prExtend}, // Mn [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR - {0xA983, 0xA983, prSpacingMark}, // Mc JAVANESE SIGN WIGNYAN - {0xA9B3, 0xA9B3, prExtend}, // Mn JAVANESE SIGN CECAK TELU - {0xA9B4, 0xA9B5, prSpacingMark}, // Mc [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG - {0xA9B6, 0xA9B9, prExtend}, // Mn [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT - {0xA9BA, 0xA9BB, prSpacingMark}, // Mc [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE - {0xA9BC, 0xA9BD, prExtend}, // Mn [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET - {0xA9BE, 0xA9C0, prSpacingMark}, // Mc [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON - {0xA9E5, 0xA9E5, prExtend}, // Mn MYANMAR SIGN SHAN SAW - {0xAA29, 0xAA2E, prExtend}, // Mn [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE - {0xAA2F, 0xAA30, prSpacingMark}, // Mc [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI - {0xAA31, 0xAA32, prExtend}, // Mn [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE - {0xAA33, 0xAA34, prSpacingMark}, // Mc [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA - {0xAA35, 0xAA36, prExtend}, // Mn [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA - {0xAA43, 0xAA43, prExtend}, // Mn CHAM CONSONANT SIGN FINAL NG - {0xAA4C, 0xAA4C, prExtend}, // Mn CHAM CONSONANT SIGN FINAL M - {0xAA4D, 0xAA4D, prSpacingMark}, // Mc CHAM CONSONANT SIGN FINAL H - {0xAA7C, 0xAA7C, prExtend}, // Mn MYANMAR SIGN TAI LAING TONE-2 - {0xAAB0, 0xAAB0, prExtend}, // Mn TAI VIET MAI KANG - {0xAAB2, 0xAAB4, prExtend}, // Mn [3] TAI VIET VOWEL I..TAI VIET VOWEL U - {0xAAB7, 0xAAB8, prExtend}, // Mn [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA - {0xAABE, 0xAABF, prExtend}, // Mn [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK - {0xAAC1, 0xAAC1, prExtend}, // Mn TAI VIET TONE MAI THO - {0xAAEB, 0xAAEB, prSpacingMark}, // Mc MEETEI MAYEK VOWEL SIGN II - {0xAAEC, 0xAAED, prExtend}, // Mn [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI - {0xAAEE, 0xAAEF, prSpacingMark}, // Mc [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU - {0xAAF5, 0xAAF5, prSpacingMark}, // Mc MEETEI MAYEK VOWEL SIGN VISARGA - {0xAAF6, 0xAAF6, prExtend}, // Mn MEETEI MAYEK VIRAMA - {0xABE3, 0xABE4, prSpacingMark}, // Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP - {0xABE5, 0xABE5, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN ANAP - {0xABE6, 0xABE7, prSpacingMark}, // Mc [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP - {0xABE8, 0xABE8, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN UNAP - {0xABE9, 0xABEA, prSpacingMark}, // Mc [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG - {0xABEC, 0xABEC, prSpacingMark}, // Mc MEETEI MAYEK LUM IYEK - {0xABED, 0xABED, prExtend}, // Mn MEETEI MAYEK APUN IYEK - {0xAC00, 0xAC00, prLV}, // Lo HANGUL SYLLABLE GA - {0xAC01, 0xAC1B, prLVT}, // Lo [27] HANGUL SYLLABLE GAG..HANGUL SYLLABLE GAH - {0xAC1C, 0xAC1C, prLV}, // Lo HANGUL SYLLABLE GAE - {0xAC1D, 0xAC37, prLVT}, // Lo [27] HANGUL SYLLABLE GAEG..HANGUL SYLLABLE GAEH - {0xAC38, 0xAC38, prLV}, // Lo HANGUL SYLLABLE GYA - {0xAC39, 0xAC53, prLVT}, // Lo [27] HANGUL SYLLABLE GYAG..HANGUL SYLLABLE GYAH - {0xAC54, 0xAC54, prLV}, // Lo HANGUL SYLLABLE GYAE - {0xAC55, 0xAC6F, prLVT}, // Lo [27] HANGUL SYLLABLE GYAEG..HANGUL SYLLABLE GYAEH - {0xAC70, 0xAC70, prLV}, // Lo HANGUL SYLLABLE GEO - {0xAC71, 0xAC8B, prLVT}, // Lo [27] HANGUL SYLLABLE GEOG..HANGUL SYLLABLE GEOH - {0xAC8C, 0xAC8C, prLV}, // Lo HANGUL SYLLABLE GE - {0xAC8D, 0xACA7, prLVT}, // Lo [27] HANGUL SYLLABLE GEG..HANGUL SYLLABLE GEH - {0xACA8, 0xACA8, prLV}, // Lo HANGUL SYLLABLE GYEO - {0xACA9, 0xACC3, prLVT}, // Lo [27] HANGUL SYLLABLE GYEOG..HANGUL SYLLABLE GYEOH - {0xACC4, 0xACC4, prLV}, // Lo HANGUL SYLLABLE GYE - {0xACC5, 0xACDF, prLVT}, // Lo [27] HANGUL SYLLABLE GYEG..HANGUL SYLLABLE GYEH - {0xACE0, 0xACE0, prLV}, // Lo HANGUL SYLLABLE GO - {0xACE1, 0xACFB, prLVT}, // Lo [27] HANGUL SYLLABLE GOG..HANGUL SYLLABLE GOH - {0xACFC, 0xACFC, prLV}, // Lo HANGUL SYLLABLE GWA - {0xACFD, 0xAD17, prLVT}, // Lo [27] HANGUL SYLLABLE GWAG..HANGUL SYLLABLE GWAH - {0xAD18, 0xAD18, prLV}, // Lo HANGUL SYLLABLE GWAE - {0xAD19, 0xAD33, prLVT}, // Lo [27] HANGUL SYLLABLE GWAEG..HANGUL SYLLABLE GWAEH - {0xAD34, 0xAD34, prLV}, // Lo HANGUL SYLLABLE GOE - {0xAD35, 0xAD4F, prLVT}, // Lo [27] HANGUL SYLLABLE GOEG..HANGUL SYLLABLE GOEH - {0xAD50, 0xAD50, prLV}, // Lo HANGUL SYLLABLE GYO - {0xAD51, 0xAD6B, prLVT}, // Lo [27] HANGUL SYLLABLE GYOG..HANGUL SYLLABLE GYOH - {0xAD6C, 0xAD6C, prLV}, // Lo HANGUL SYLLABLE GU - {0xAD6D, 0xAD87, prLVT}, // Lo [27] HANGUL SYLLABLE GUG..HANGUL SYLLABLE GUH - {0xAD88, 0xAD88, prLV}, // Lo HANGUL SYLLABLE GWEO - {0xAD89, 0xADA3, prLVT}, // Lo [27] HANGUL SYLLABLE GWEOG..HANGUL SYLLABLE GWEOH - {0xADA4, 0xADA4, prLV}, // Lo HANGUL SYLLABLE GWE - {0xADA5, 0xADBF, prLVT}, // Lo [27] HANGUL SYLLABLE GWEG..HANGUL SYLLABLE GWEH - {0xADC0, 0xADC0, prLV}, // Lo HANGUL SYLLABLE GWI - {0xADC1, 0xADDB, prLVT}, // Lo [27] HANGUL SYLLABLE GWIG..HANGUL SYLLABLE GWIH - {0xADDC, 0xADDC, prLV}, // Lo HANGUL SYLLABLE GYU - {0xADDD, 0xADF7, prLVT}, // Lo [27] HANGUL SYLLABLE GYUG..HANGUL SYLLABLE GYUH - {0xADF8, 0xADF8, prLV}, // Lo HANGUL SYLLABLE GEU - {0xADF9, 0xAE13, prLVT}, // Lo [27] HANGUL SYLLABLE GEUG..HANGUL SYLLABLE GEUH - {0xAE14, 0xAE14, prLV}, // Lo HANGUL SYLLABLE GYI - {0xAE15, 0xAE2F, prLVT}, // Lo [27] HANGUL SYLLABLE GYIG..HANGUL SYLLABLE GYIH - {0xAE30, 0xAE30, prLV}, // Lo HANGUL SYLLABLE GI - {0xAE31, 0xAE4B, prLVT}, // Lo [27] HANGUL SYLLABLE GIG..HANGUL SYLLABLE GIH - {0xAE4C, 0xAE4C, prLV}, // Lo HANGUL SYLLABLE GGA - {0xAE4D, 0xAE67, prLVT}, // Lo [27] HANGUL SYLLABLE GGAG..HANGUL SYLLABLE GGAH - {0xAE68, 0xAE68, prLV}, // Lo HANGUL SYLLABLE GGAE - {0xAE69, 0xAE83, prLVT}, // Lo [27] HANGUL SYLLABLE GGAEG..HANGUL SYLLABLE GGAEH - {0xAE84, 0xAE84, prLV}, // Lo HANGUL SYLLABLE GGYA - {0xAE85, 0xAE9F, prLVT}, // Lo [27] HANGUL SYLLABLE GGYAG..HANGUL SYLLABLE GGYAH - {0xAEA0, 0xAEA0, prLV}, // Lo HANGUL SYLLABLE GGYAE - {0xAEA1, 0xAEBB, prLVT}, // Lo [27] HANGUL SYLLABLE GGYAEG..HANGUL SYLLABLE GGYAEH - {0xAEBC, 0xAEBC, prLV}, // Lo HANGUL SYLLABLE GGEO - {0xAEBD, 0xAED7, prLVT}, // Lo [27] HANGUL SYLLABLE GGEOG..HANGUL SYLLABLE GGEOH - {0xAED8, 0xAED8, prLV}, // Lo HANGUL SYLLABLE GGE - {0xAED9, 0xAEF3, prLVT}, // Lo [27] HANGUL SYLLABLE GGEG..HANGUL SYLLABLE GGEH - {0xAEF4, 0xAEF4, prLV}, // Lo HANGUL SYLLABLE GGYEO - {0xAEF5, 0xAF0F, prLVT}, // Lo [27] HANGUL SYLLABLE GGYEOG..HANGUL SYLLABLE GGYEOH - {0xAF10, 0xAF10, prLV}, // Lo HANGUL SYLLABLE GGYE - {0xAF11, 0xAF2B, prLVT}, // Lo [27] HANGUL SYLLABLE GGYEG..HANGUL SYLLABLE GGYEH - {0xAF2C, 0xAF2C, prLV}, // Lo HANGUL SYLLABLE GGO - {0xAF2D, 0xAF47, prLVT}, // Lo [27] HANGUL SYLLABLE GGOG..HANGUL SYLLABLE GGOH - {0xAF48, 0xAF48, prLV}, // Lo HANGUL SYLLABLE GGWA - {0xAF49, 0xAF63, prLVT}, // Lo [27] HANGUL SYLLABLE GGWAG..HANGUL SYLLABLE GGWAH - {0xAF64, 0xAF64, prLV}, // Lo HANGUL SYLLABLE GGWAE - {0xAF65, 0xAF7F, prLVT}, // Lo [27] HANGUL SYLLABLE GGWAEG..HANGUL SYLLABLE GGWAEH - {0xAF80, 0xAF80, prLV}, // Lo HANGUL SYLLABLE GGOE - {0xAF81, 0xAF9B, prLVT}, // Lo [27] HANGUL SYLLABLE GGOEG..HANGUL SYLLABLE GGOEH - {0xAF9C, 0xAF9C, prLV}, // Lo HANGUL SYLLABLE GGYO - {0xAF9D, 0xAFB7, prLVT}, // Lo [27] HANGUL SYLLABLE GGYOG..HANGUL SYLLABLE GGYOH - {0xAFB8, 0xAFB8, prLV}, // Lo HANGUL SYLLABLE GGU - {0xAFB9, 0xAFD3, prLVT}, // Lo [27] HANGUL SYLLABLE GGUG..HANGUL SYLLABLE GGUH - {0xAFD4, 0xAFD4, prLV}, // Lo HANGUL SYLLABLE GGWEO - {0xAFD5, 0xAFEF, prLVT}, // Lo [27] HANGUL SYLLABLE GGWEOG..HANGUL SYLLABLE GGWEOH - {0xAFF0, 0xAFF0, prLV}, // Lo HANGUL SYLLABLE GGWE - {0xAFF1, 0xB00B, prLVT}, // Lo [27] HANGUL SYLLABLE GGWEG..HANGUL SYLLABLE GGWEH - {0xB00C, 0xB00C, prLV}, // Lo HANGUL SYLLABLE GGWI - {0xB00D, 0xB027, prLVT}, // Lo [27] HANGUL SYLLABLE GGWIG..HANGUL SYLLABLE GGWIH - {0xB028, 0xB028, prLV}, // Lo HANGUL SYLLABLE GGYU - {0xB029, 0xB043, prLVT}, // Lo [27] HANGUL SYLLABLE GGYUG..HANGUL SYLLABLE GGYUH - {0xB044, 0xB044, prLV}, // Lo HANGUL SYLLABLE GGEU - {0xB045, 0xB05F, prLVT}, // Lo [27] HANGUL SYLLABLE GGEUG..HANGUL SYLLABLE GGEUH - {0xB060, 0xB060, prLV}, // Lo HANGUL SYLLABLE GGYI - {0xB061, 0xB07B, prLVT}, // Lo [27] HANGUL SYLLABLE GGYIG..HANGUL SYLLABLE GGYIH - {0xB07C, 0xB07C, prLV}, // Lo HANGUL SYLLABLE GGI - {0xB07D, 0xB097, prLVT}, // Lo [27] HANGUL SYLLABLE GGIG..HANGUL SYLLABLE GGIH - {0xB098, 0xB098, prLV}, // Lo HANGUL SYLLABLE NA - {0xB099, 0xB0B3, prLVT}, // Lo [27] HANGUL SYLLABLE NAG..HANGUL SYLLABLE NAH - {0xB0B4, 0xB0B4, prLV}, // Lo HANGUL SYLLABLE NAE - {0xB0B5, 0xB0CF, prLVT}, // Lo [27] HANGUL SYLLABLE NAEG..HANGUL SYLLABLE NAEH - {0xB0D0, 0xB0D0, prLV}, // Lo HANGUL SYLLABLE NYA - {0xB0D1, 0xB0EB, prLVT}, // Lo [27] HANGUL SYLLABLE NYAG..HANGUL SYLLABLE NYAH - {0xB0EC, 0xB0EC, prLV}, // Lo HANGUL SYLLABLE NYAE - {0xB0ED, 0xB107, prLVT}, // Lo [27] HANGUL SYLLABLE NYAEG..HANGUL SYLLABLE NYAEH - {0xB108, 0xB108, prLV}, // Lo HANGUL SYLLABLE NEO - {0xB109, 0xB123, prLVT}, // Lo [27] HANGUL SYLLABLE NEOG..HANGUL SYLLABLE NEOH - {0xB124, 0xB124, prLV}, // Lo HANGUL SYLLABLE NE - {0xB125, 0xB13F, prLVT}, // Lo [27] HANGUL SYLLABLE NEG..HANGUL SYLLABLE NEH - {0xB140, 0xB140, prLV}, // Lo HANGUL SYLLABLE NYEO - {0xB141, 0xB15B, prLVT}, // Lo [27] HANGUL SYLLABLE NYEOG..HANGUL SYLLABLE NYEOH - {0xB15C, 0xB15C, prLV}, // Lo HANGUL SYLLABLE NYE - {0xB15D, 0xB177, prLVT}, // Lo [27] HANGUL SYLLABLE NYEG..HANGUL SYLLABLE NYEH - {0xB178, 0xB178, prLV}, // Lo HANGUL SYLLABLE NO - {0xB179, 0xB193, prLVT}, // Lo [27] HANGUL SYLLABLE NOG..HANGUL SYLLABLE NOH - {0xB194, 0xB194, prLV}, // Lo HANGUL SYLLABLE NWA - {0xB195, 0xB1AF, prLVT}, // Lo [27] HANGUL SYLLABLE NWAG..HANGUL SYLLABLE NWAH - {0xB1B0, 0xB1B0, prLV}, // Lo HANGUL SYLLABLE NWAE - {0xB1B1, 0xB1CB, prLVT}, // Lo [27] HANGUL SYLLABLE NWAEG..HANGUL SYLLABLE NWAEH - {0xB1CC, 0xB1CC, prLV}, // Lo HANGUL SYLLABLE NOE - {0xB1CD, 0xB1E7, prLVT}, // Lo [27] HANGUL SYLLABLE NOEG..HANGUL SYLLABLE NOEH - {0xB1E8, 0xB1E8, prLV}, // Lo HANGUL SYLLABLE NYO - {0xB1E9, 0xB203, prLVT}, // Lo [27] HANGUL SYLLABLE NYOG..HANGUL SYLLABLE NYOH - {0xB204, 0xB204, prLV}, // Lo HANGUL SYLLABLE NU - {0xB205, 0xB21F, prLVT}, // Lo [27] HANGUL SYLLABLE NUG..HANGUL SYLLABLE NUH - {0xB220, 0xB220, prLV}, // Lo HANGUL SYLLABLE NWEO - {0xB221, 0xB23B, prLVT}, // Lo [27] HANGUL SYLLABLE NWEOG..HANGUL SYLLABLE NWEOH - {0xB23C, 0xB23C, prLV}, // Lo HANGUL SYLLABLE NWE - {0xB23D, 0xB257, prLVT}, // Lo [27] HANGUL SYLLABLE NWEG..HANGUL SYLLABLE NWEH - {0xB258, 0xB258, prLV}, // Lo HANGUL SYLLABLE NWI - {0xB259, 0xB273, prLVT}, // Lo [27] HANGUL SYLLABLE NWIG..HANGUL SYLLABLE NWIH - {0xB274, 0xB274, prLV}, // Lo HANGUL SYLLABLE NYU - {0xB275, 0xB28F, prLVT}, // Lo [27] HANGUL SYLLABLE NYUG..HANGUL SYLLABLE NYUH - {0xB290, 0xB290, prLV}, // Lo HANGUL SYLLABLE NEU - {0xB291, 0xB2AB, prLVT}, // Lo [27] HANGUL SYLLABLE NEUG..HANGUL SYLLABLE NEUH - {0xB2AC, 0xB2AC, prLV}, // Lo HANGUL SYLLABLE NYI - {0xB2AD, 0xB2C7, prLVT}, // Lo [27] HANGUL SYLLABLE NYIG..HANGUL SYLLABLE NYIH - {0xB2C8, 0xB2C8, prLV}, // Lo HANGUL SYLLABLE NI - {0xB2C9, 0xB2E3, prLVT}, // Lo [27] HANGUL SYLLABLE NIG..HANGUL SYLLABLE NIH - {0xB2E4, 0xB2E4, prLV}, // Lo HANGUL SYLLABLE DA - {0xB2E5, 0xB2FF, prLVT}, // Lo [27] HANGUL SYLLABLE DAG..HANGUL SYLLABLE DAH - {0xB300, 0xB300, prLV}, // Lo HANGUL SYLLABLE DAE - {0xB301, 0xB31B, prLVT}, // Lo [27] HANGUL SYLLABLE DAEG..HANGUL SYLLABLE DAEH - {0xB31C, 0xB31C, prLV}, // Lo HANGUL SYLLABLE DYA - {0xB31D, 0xB337, prLVT}, // Lo [27] HANGUL SYLLABLE DYAG..HANGUL SYLLABLE DYAH - {0xB338, 0xB338, prLV}, // Lo HANGUL SYLLABLE DYAE - {0xB339, 0xB353, prLVT}, // Lo [27] HANGUL SYLLABLE DYAEG..HANGUL SYLLABLE DYAEH - {0xB354, 0xB354, prLV}, // Lo HANGUL SYLLABLE DEO - {0xB355, 0xB36F, prLVT}, // Lo [27] HANGUL SYLLABLE DEOG..HANGUL SYLLABLE DEOH - {0xB370, 0xB370, prLV}, // Lo HANGUL SYLLABLE DE - {0xB371, 0xB38B, prLVT}, // Lo [27] HANGUL SYLLABLE DEG..HANGUL SYLLABLE DEH - {0xB38C, 0xB38C, prLV}, // Lo HANGUL SYLLABLE DYEO - {0xB38D, 0xB3A7, prLVT}, // Lo [27] HANGUL SYLLABLE DYEOG..HANGUL SYLLABLE DYEOH - {0xB3A8, 0xB3A8, prLV}, // Lo HANGUL SYLLABLE DYE - {0xB3A9, 0xB3C3, prLVT}, // Lo [27] HANGUL SYLLABLE DYEG..HANGUL SYLLABLE DYEH - {0xB3C4, 0xB3C4, prLV}, // Lo HANGUL SYLLABLE DO - {0xB3C5, 0xB3DF, prLVT}, // Lo [27] HANGUL SYLLABLE DOG..HANGUL SYLLABLE DOH - {0xB3E0, 0xB3E0, prLV}, // Lo HANGUL SYLLABLE DWA - {0xB3E1, 0xB3FB, prLVT}, // Lo [27] HANGUL SYLLABLE DWAG..HANGUL SYLLABLE DWAH - {0xB3FC, 0xB3FC, prLV}, // Lo HANGUL SYLLABLE DWAE - {0xB3FD, 0xB417, prLVT}, // Lo [27] HANGUL SYLLABLE DWAEG..HANGUL SYLLABLE DWAEH - {0xB418, 0xB418, prLV}, // Lo HANGUL SYLLABLE DOE - {0xB419, 0xB433, prLVT}, // Lo [27] HANGUL SYLLABLE DOEG..HANGUL SYLLABLE DOEH - {0xB434, 0xB434, prLV}, // Lo HANGUL SYLLABLE DYO - {0xB435, 0xB44F, prLVT}, // Lo [27] HANGUL SYLLABLE DYOG..HANGUL SYLLABLE DYOH - {0xB450, 0xB450, prLV}, // Lo HANGUL SYLLABLE DU - {0xB451, 0xB46B, prLVT}, // Lo [27] HANGUL SYLLABLE DUG..HANGUL SYLLABLE DUH - {0xB46C, 0xB46C, prLV}, // Lo HANGUL SYLLABLE DWEO - {0xB46D, 0xB487, prLVT}, // Lo [27] HANGUL SYLLABLE DWEOG..HANGUL SYLLABLE DWEOH - {0xB488, 0xB488, prLV}, // Lo HANGUL SYLLABLE DWE - {0xB489, 0xB4A3, prLVT}, // Lo [27] HANGUL SYLLABLE DWEG..HANGUL SYLLABLE DWEH - {0xB4A4, 0xB4A4, prLV}, // Lo HANGUL SYLLABLE DWI - {0xB4A5, 0xB4BF, prLVT}, // Lo [27] HANGUL SYLLABLE DWIG..HANGUL SYLLABLE DWIH - {0xB4C0, 0xB4C0, prLV}, // Lo HANGUL SYLLABLE DYU - {0xB4C1, 0xB4DB, prLVT}, // Lo [27] HANGUL SYLLABLE DYUG..HANGUL SYLLABLE DYUH - {0xB4DC, 0xB4DC, prLV}, // Lo HANGUL SYLLABLE DEU - {0xB4DD, 0xB4F7, prLVT}, // Lo [27] HANGUL SYLLABLE DEUG..HANGUL SYLLABLE DEUH - {0xB4F8, 0xB4F8, prLV}, // Lo HANGUL SYLLABLE DYI - {0xB4F9, 0xB513, prLVT}, // Lo [27] HANGUL SYLLABLE DYIG..HANGUL SYLLABLE DYIH - {0xB514, 0xB514, prLV}, // Lo HANGUL SYLLABLE DI - {0xB515, 0xB52F, prLVT}, // Lo [27] HANGUL SYLLABLE DIG..HANGUL SYLLABLE DIH - {0xB530, 0xB530, prLV}, // Lo HANGUL SYLLABLE DDA - {0xB531, 0xB54B, prLVT}, // Lo [27] HANGUL SYLLABLE DDAG..HANGUL SYLLABLE DDAH - {0xB54C, 0xB54C, prLV}, // Lo HANGUL SYLLABLE DDAE - {0xB54D, 0xB567, prLVT}, // Lo [27] HANGUL SYLLABLE DDAEG..HANGUL SYLLABLE DDAEH - {0xB568, 0xB568, prLV}, // Lo HANGUL SYLLABLE DDYA - {0xB569, 0xB583, prLVT}, // Lo [27] HANGUL SYLLABLE DDYAG..HANGUL SYLLABLE DDYAH - {0xB584, 0xB584, prLV}, // Lo HANGUL SYLLABLE DDYAE - {0xB585, 0xB59F, prLVT}, // Lo [27] HANGUL SYLLABLE DDYAEG..HANGUL SYLLABLE DDYAEH - {0xB5A0, 0xB5A0, prLV}, // Lo HANGUL SYLLABLE DDEO - {0xB5A1, 0xB5BB, prLVT}, // Lo [27] HANGUL SYLLABLE DDEOG..HANGUL SYLLABLE DDEOH - {0xB5BC, 0xB5BC, prLV}, // Lo HANGUL SYLLABLE DDE - {0xB5BD, 0xB5D7, prLVT}, // Lo [27] HANGUL SYLLABLE DDEG..HANGUL SYLLABLE DDEH - {0xB5D8, 0xB5D8, prLV}, // Lo HANGUL SYLLABLE DDYEO - {0xB5D9, 0xB5F3, prLVT}, // Lo [27] HANGUL SYLLABLE DDYEOG..HANGUL SYLLABLE DDYEOH - {0xB5F4, 0xB5F4, prLV}, // Lo HANGUL SYLLABLE DDYE - {0xB5F5, 0xB60F, prLVT}, // Lo [27] HANGUL SYLLABLE DDYEG..HANGUL SYLLABLE DDYEH - {0xB610, 0xB610, prLV}, // Lo HANGUL SYLLABLE DDO - {0xB611, 0xB62B, prLVT}, // Lo [27] HANGUL SYLLABLE DDOG..HANGUL SYLLABLE DDOH - {0xB62C, 0xB62C, prLV}, // Lo HANGUL SYLLABLE DDWA - {0xB62D, 0xB647, prLVT}, // Lo [27] HANGUL SYLLABLE DDWAG..HANGUL SYLLABLE DDWAH - {0xB648, 0xB648, prLV}, // Lo HANGUL SYLLABLE DDWAE - {0xB649, 0xB663, prLVT}, // Lo [27] HANGUL SYLLABLE DDWAEG..HANGUL SYLLABLE DDWAEH - {0xB664, 0xB664, prLV}, // Lo HANGUL SYLLABLE DDOE - {0xB665, 0xB67F, prLVT}, // Lo [27] HANGUL SYLLABLE DDOEG..HANGUL SYLLABLE DDOEH - {0xB680, 0xB680, prLV}, // Lo HANGUL SYLLABLE DDYO - {0xB681, 0xB69B, prLVT}, // Lo [27] HANGUL SYLLABLE DDYOG..HANGUL SYLLABLE DDYOH - {0xB69C, 0xB69C, prLV}, // Lo HANGUL SYLLABLE DDU - {0xB69D, 0xB6B7, prLVT}, // Lo [27] HANGUL SYLLABLE DDUG..HANGUL SYLLABLE DDUH - {0xB6B8, 0xB6B8, prLV}, // Lo HANGUL SYLLABLE DDWEO - {0xB6B9, 0xB6D3, prLVT}, // Lo [27] HANGUL SYLLABLE DDWEOG..HANGUL SYLLABLE DDWEOH - {0xB6D4, 0xB6D4, prLV}, // Lo HANGUL SYLLABLE DDWE - {0xB6D5, 0xB6EF, prLVT}, // Lo [27] HANGUL SYLLABLE DDWEG..HANGUL SYLLABLE DDWEH - {0xB6F0, 0xB6F0, prLV}, // Lo HANGUL SYLLABLE DDWI - {0xB6F1, 0xB70B, prLVT}, // Lo [27] HANGUL SYLLABLE DDWIG..HANGUL SYLLABLE DDWIH - {0xB70C, 0xB70C, prLV}, // Lo HANGUL SYLLABLE DDYU - {0xB70D, 0xB727, prLVT}, // Lo [27] HANGUL SYLLABLE DDYUG..HANGUL SYLLABLE DDYUH - {0xB728, 0xB728, prLV}, // Lo HANGUL SYLLABLE DDEU - {0xB729, 0xB743, prLVT}, // Lo [27] HANGUL SYLLABLE DDEUG..HANGUL SYLLABLE DDEUH - {0xB744, 0xB744, prLV}, // Lo HANGUL SYLLABLE DDYI - {0xB745, 0xB75F, prLVT}, // Lo [27] HANGUL SYLLABLE DDYIG..HANGUL SYLLABLE DDYIH - {0xB760, 0xB760, prLV}, // Lo HANGUL SYLLABLE DDI - {0xB761, 0xB77B, prLVT}, // Lo [27] HANGUL SYLLABLE DDIG..HANGUL SYLLABLE DDIH - {0xB77C, 0xB77C, prLV}, // Lo HANGUL SYLLABLE RA - {0xB77D, 0xB797, prLVT}, // Lo [27] HANGUL SYLLABLE RAG..HANGUL SYLLABLE RAH - {0xB798, 0xB798, prLV}, // Lo HANGUL SYLLABLE RAE - {0xB799, 0xB7B3, prLVT}, // Lo [27] HANGUL SYLLABLE RAEG..HANGUL SYLLABLE RAEH - {0xB7B4, 0xB7B4, prLV}, // Lo HANGUL SYLLABLE RYA - {0xB7B5, 0xB7CF, prLVT}, // Lo [27] HANGUL SYLLABLE RYAG..HANGUL SYLLABLE RYAH - {0xB7D0, 0xB7D0, prLV}, // Lo HANGUL SYLLABLE RYAE - {0xB7D1, 0xB7EB, prLVT}, // Lo [27] HANGUL SYLLABLE RYAEG..HANGUL SYLLABLE RYAEH - {0xB7EC, 0xB7EC, prLV}, // Lo HANGUL SYLLABLE REO - {0xB7ED, 0xB807, prLVT}, // Lo [27] HANGUL SYLLABLE REOG..HANGUL SYLLABLE REOH - {0xB808, 0xB808, prLV}, // Lo HANGUL SYLLABLE RE - {0xB809, 0xB823, prLVT}, // Lo [27] HANGUL SYLLABLE REG..HANGUL SYLLABLE REH - {0xB824, 0xB824, prLV}, // Lo HANGUL SYLLABLE RYEO - {0xB825, 0xB83F, prLVT}, // Lo [27] HANGUL SYLLABLE RYEOG..HANGUL SYLLABLE RYEOH - {0xB840, 0xB840, prLV}, // Lo HANGUL SYLLABLE RYE - {0xB841, 0xB85B, prLVT}, // Lo [27] HANGUL SYLLABLE RYEG..HANGUL SYLLABLE RYEH - {0xB85C, 0xB85C, prLV}, // Lo HANGUL SYLLABLE RO - {0xB85D, 0xB877, prLVT}, // Lo [27] HANGUL SYLLABLE ROG..HANGUL SYLLABLE ROH - {0xB878, 0xB878, prLV}, // Lo HANGUL SYLLABLE RWA - {0xB879, 0xB893, prLVT}, // Lo [27] HANGUL SYLLABLE RWAG..HANGUL SYLLABLE RWAH - {0xB894, 0xB894, prLV}, // Lo HANGUL SYLLABLE RWAE - {0xB895, 0xB8AF, prLVT}, // Lo [27] HANGUL SYLLABLE RWAEG..HANGUL SYLLABLE RWAEH - {0xB8B0, 0xB8B0, prLV}, // Lo HANGUL SYLLABLE ROE - {0xB8B1, 0xB8CB, prLVT}, // Lo [27] HANGUL SYLLABLE ROEG..HANGUL SYLLABLE ROEH - {0xB8CC, 0xB8CC, prLV}, // Lo HANGUL SYLLABLE RYO - {0xB8CD, 0xB8E7, prLVT}, // Lo [27] HANGUL SYLLABLE RYOG..HANGUL SYLLABLE RYOH - {0xB8E8, 0xB8E8, prLV}, // Lo HANGUL SYLLABLE RU - {0xB8E9, 0xB903, prLVT}, // Lo [27] HANGUL SYLLABLE RUG..HANGUL SYLLABLE RUH - {0xB904, 0xB904, prLV}, // Lo HANGUL SYLLABLE RWEO - {0xB905, 0xB91F, prLVT}, // Lo [27] HANGUL SYLLABLE RWEOG..HANGUL SYLLABLE RWEOH - {0xB920, 0xB920, prLV}, // Lo HANGUL SYLLABLE RWE - {0xB921, 0xB93B, prLVT}, // Lo [27] HANGUL SYLLABLE RWEG..HANGUL SYLLABLE RWEH - {0xB93C, 0xB93C, prLV}, // Lo HANGUL SYLLABLE RWI - {0xB93D, 0xB957, prLVT}, // Lo [27] HANGUL SYLLABLE RWIG..HANGUL SYLLABLE RWIH - {0xB958, 0xB958, prLV}, // Lo HANGUL SYLLABLE RYU - {0xB959, 0xB973, prLVT}, // Lo [27] HANGUL SYLLABLE RYUG..HANGUL SYLLABLE RYUH - {0xB974, 0xB974, prLV}, // Lo HANGUL SYLLABLE REU - {0xB975, 0xB98F, prLVT}, // Lo [27] HANGUL SYLLABLE REUG..HANGUL SYLLABLE REUH - {0xB990, 0xB990, prLV}, // Lo HANGUL SYLLABLE RYI - {0xB991, 0xB9AB, prLVT}, // Lo [27] HANGUL SYLLABLE RYIG..HANGUL SYLLABLE RYIH - {0xB9AC, 0xB9AC, prLV}, // Lo HANGUL SYLLABLE RI - {0xB9AD, 0xB9C7, prLVT}, // Lo [27] HANGUL SYLLABLE RIG..HANGUL SYLLABLE RIH - {0xB9C8, 0xB9C8, prLV}, // Lo HANGUL SYLLABLE MA - {0xB9C9, 0xB9E3, prLVT}, // Lo [27] HANGUL SYLLABLE MAG..HANGUL SYLLABLE MAH - {0xB9E4, 0xB9E4, prLV}, // Lo HANGUL SYLLABLE MAE - {0xB9E5, 0xB9FF, prLVT}, // Lo [27] HANGUL SYLLABLE MAEG..HANGUL SYLLABLE MAEH - {0xBA00, 0xBA00, prLV}, // Lo HANGUL SYLLABLE MYA - {0xBA01, 0xBA1B, prLVT}, // Lo [27] HANGUL SYLLABLE MYAG..HANGUL SYLLABLE MYAH - {0xBA1C, 0xBA1C, prLV}, // Lo HANGUL SYLLABLE MYAE - {0xBA1D, 0xBA37, prLVT}, // Lo [27] HANGUL SYLLABLE MYAEG..HANGUL SYLLABLE MYAEH - {0xBA38, 0xBA38, prLV}, // Lo HANGUL SYLLABLE MEO - {0xBA39, 0xBA53, prLVT}, // Lo [27] HANGUL SYLLABLE MEOG..HANGUL SYLLABLE MEOH - {0xBA54, 0xBA54, prLV}, // Lo HANGUL SYLLABLE ME - {0xBA55, 0xBA6F, prLVT}, // Lo [27] HANGUL SYLLABLE MEG..HANGUL SYLLABLE MEH - {0xBA70, 0xBA70, prLV}, // Lo HANGUL SYLLABLE MYEO - {0xBA71, 0xBA8B, prLVT}, // Lo [27] HANGUL SYLLABLE MYEOG..HANGUL SYLLABLE MYEOH - {0xBA8C, 0xBA8C, prLV}, // Lo HANGUL SYLLABLE MYE - {0xBA8D, 0xBAA7, prLVT}, // Lo [27] HANGUL SYLLABLE MYEG..HANGUL SYLLABLE MYEH - {0xBAA8, 0xBAA8, prLV}, // Lo HANGUL SYLLABLE MO - {0xBAA9, 0xBAC3, prLVT}, // Lo [27] HANGUL SYLLABLE MOG..HANGUL SYLLABLE MOH - {0xBAC4, 0xBAC4, prLV}, // Lo HANGUL SYLLABLE MWA - {0xBAC5, 0xBADF, prLVT}, // Lo [27] HANGUL SYLLABLE MWAG..HANGUL SYLLABLE MWAH - {0xBAE0, 0xBAE0, prLV}, // Lo HANGUL SYLLABLE MWAE - {0xBAE1, 0xBAFB, prLVT}, // Lo [27] HANGUL SYLLABLE MWAEG..HANGUL SYLLABLE MWAEH - {0xBAFC, 0xBAFC, prLV}, // Lo HANGUL SYLLABLE MOE - {0xBAFD, 0xBB17, prLVT}, // Lo [27] HANGUL SYLLABLE MOEG..HANGUL SYLLABLE MOEH - {0xBB18, 0xBB18, prLV}, // Lo HANGUL SYLLABLE MYO - {0xBB19, 0xBB33, prLVT}, // Lo [27] HANGUL SYLLABLE MYOG..HANGUL SYLLABLE MYOH - {0xBB34, 0xBB34, prLV}, // Lo HANGUL SYLLABLE MU - {0xBB35, 0xBB4F, prLVT}, // Lo [27] HANGUL SYLLABLE MUG..HANGUL SYLLABLE MUH - {0xBB50, 0xBB50, prLV}, // Lo HANGUL SYLLABLE MWEO - {0xBB51, 0xBB6B, prLVT}, // Lo [27] HANGUL SYLLABLE MWEOG..HANGUL SYLLABLE MWEOH - {0xBB6C, 0xBB6C, prLV}, // Lo HANGUL SYLLABLE MWE - {0xBB6D, 0xBB87, prLVT}, // Lo [27] HANGUL SYLLABLE MWEG..HANGUL SYLLABLE MWEH - {0xBB88, 0xBB88, prLV}, // Lo HANGUL SYLLABLE MWI - {0xBB89, 0xBBA3, prLVT}, // Lo [27] HANGUL SYLLABLE MWIG..HANGUL SYLLABLE MWIH - {0xBBA4, 0xBBA4, prLV}, // Lo HANGUL SYLLABLE MYU - {0xBBA5, 0xBBBF, prLVT}, // Lo [27] HANGUL SYLLABLE MYUG..HANGUL SYLLABLE MYUH - {0xBBC0, 0xBBC0, prLV}, // Lo HANGUL SYLLABLE MEU - {0xBBC1, 0xBBDB, prLVT}, // Lo [27] HANGUL SYLLABLE MEUG..HANGUL SYLLABLE MEUH - {0xBBDC, 0xBBDC, prLV}, // Lo HANGUL SYLLABLE MYI - {0xBBDD, 0xBBF7, prLVT}, // Lo [27] HANGUL SYLLABLE MYIG..HANGUL SYLLABLE MYIH - {0xBBF8, 0xBBF8, prLV}, // Lo HANGUL SYLLABLE MI - {0xBBF9, 0xBC13, prLVT}, // Lo [27] HANGUL SYLLABLE MIG..HANGUL SYLLABLE MIH - {0xBC14, 0xBC14, prLV}, // Lo HANGUL SYLLABLE BA - {0xBC15, 0xBC2F, prLVT}, // Lo [27] HANGUL SYLLABLE BAG..HANGUL SYLLABLE BAH - {0xBC30, 0xBC30, prLV}, // Lo HANGUL SYLLABLE BAE - {0xBC31, 0xBC4B, prLVT}, // Lo [27] HANGUL SYLLABLE BAEG..HANGUL SYLLABLE BAEH - {0xBC4C, 0xBC4C, prLV}, // Lo HANGUL SYLLABLE BYA - {0xBC4D, 0xBC67, prLVT}, // Lo [27] HANGUL SYLLABLE BYAG..HANGUL SYLLABLE BYAH - {0xBC68, 0xBC68, prLV}, // Lo HANGUL SYLLABLE BYAE - {0xBC69, 0xBC83, prLVT}, // Lo [27] HANGUL SYLLABLE BYAEG..HANGUL SYLLABLE BYAEH - {0xBC84, 0xBC84, prLV}, // Lo HANGUL SYLLABLE BEO - {0xBC85, 0xBC9F, prLVT}, // Lo [27] HANGUL SYLLABLE BEOG..HANGUL SYLLABLE BEOH - {0xBCA0, 0xBCA0, prLV}, // Lo HANGUL SYLLABLE BE - {0xBCA1, 0xBCBB, prLVT}, // Lo [27] HANGUL SYLLABLE BEG..HANGUL SYLLABLE BEH - {0xBCBC, 0xBCBC, prLV}, // Lo HANGUL SYLLABLE BYEO - {0xBCBD, 0xBCD7, prLVT}, // Lo [27] HANGUL SYLLABLE BYEOG..HANGUL SYLLABLE BYEOH - {0xBCD8, 0xBCD8, prLV}, // Lo HANGUL SYLLABLE BYE - {0xBCD9, 0xBCF3, prLVT}, // Lo [27] HANGUL SYLLABLE BYEG..HANGUL SYLLABLE BYEH - {0xBCF4, 0xBCF4, prLV}, // Lo HANGUL SYLLABLE BO - {0xBCF5, 0xBD0F, prLVT}, // Lo [27] HANGUL SYLLABLE BOG..HANGUL SYLLABLE BOH - {0xBD10, 0xBD10, prLV}, // Lo HANGUL SYLLABLE BWA - {0xBD11, 0xBD2B, prLVT}, // Lo [27] HANGUL SYLLABLE BWAG..HANGUL SYLLABLE BWAH - {0xBD2C, 0xBD2C, prLV}, // Lo HANGUL SYLLABLE BWAE - {0xBD2D, 0xBD47, prLVT}, // Lo [27] HANGUL SYLLABLE BWAEG..HANGUL SYLLABLE BWAEH - {0xBD48, 0xBD48, prLV}, // Lo HANGUL SYLLABLE BOE - {0xBD49, 0xBD63, prLVT}, // Lo [27] HANGUL SYLLABLE BOEG..HANGUL SYLLABLE BOEH - {0xBD64, 0xBD64, prLV}, // Lo HANGUL SYLLABLE BYO - {0xBD65, 0xBD7F, prLVT}, // Lo [27] HANGUL SYLLABLE BYOG..HANGUL SYLLABLE BYOH - {0xBD80, 0xBD80, prLV}, // Lo HANGUL SYLLABLE BU - {0xBD81, 0xBD9B, prLVT}, // Lo [27] HANGUL SYLLABLE BUG..HANGUL SYLLABLE BUH - {0xBD9C, 0xBD9C, prLV}, // Lo HANGUL SYLLABLE BWEO - {0xBD9D, 0xBDB7, prLVT}, // Lo [27] HANGUL SYLLABLE BWEOG..HANGUL SYLLABLE BWEOH - {0xBDB8, 0xBDB8, prLV}, // Lo HANGUL SYLLABLE BWE - {0xBDB9, 0xBDD3, prLVT}, // Lo [27] HANGUL SYLLABLE BWEG..HANGUL SYLLABLE BWEH - {0xBDD4, 0xBDD4, prLV}, // Lo HANGUL SYLLABLE BWI - {0xBDD5, 0xBDEF, prLVT}, // Lo [27] HANGUL SYLLABLE BWIG..HANGUL SYLLABLE BWIH - {0xBDF0, 0xBDF0, prLV}, // Lo HANGUL SYLLABLE BYU - {0xBDF1, 0xBE0B, prLVT}, // Lo [27] HANGUL SYLLABLE BYUG..HANGUL SYLLABLE BYUH - {0xBE0C, 0xBE0C, prLV}, // Lo HANGUL SYLLABLE BEU - {0xBE0D, 0xBE27, prLVT}, // Lo [27] HANGUL SYLLABLE BEUG..HANGUL SYLLABLE BEUH - {0xBE28, 0xBE28, prLV}, // Lo HANGUL SYLLABLE BYI - {0xBE29, 0xBE43, prLVT}, // Lo [27] HANGUL SYLLABLE BYIG..HANGUL SYLLABLE BYIH - {0xBE44, 0xBE44, prLV}, // Lo HANGUL SYLLABLE BI - {0xBE45, 0xBE5F, prLVT}, // Lo [27] HANGUL SYLLABLE BIG..HANGUL SYLLABLE BIH - {0xBE60, 0xBE60, prLV}, // Lo HANGUL SYLLABLE BBA - {0xBE61, 0xBE7B, prLVT}, // Lo [27] HANGUL SYLLABLE BBAG..HANGUL SYLLABLE BBAH - {0xBE7C, 0xBE7C, prLV}, // Lo HANGUL SYLLABLE BBAE - {0xBE7D, 0xBE97, prLVT}, // Lo [27] HANGUL SYLLABLE BBAEG..HANGUL SYLLABLE BBAEH - {0xBE98, 0xBE98, prLV}, // Lo HANGUL SYLLABLE BBYA - {0xBE99, 0xBEB3, prLVT}, // Lo [27] HANGUL SYLLABLE BBYAG..HANGUL SYLLABLE BBYAH - {0xBEB4, 0xBEB4, prLV}, // Lo HANGUL SYLLABLE BBYAE - {0xBEB5, 0xBECF, prLVT}, // Lo [27] HANGUL SYLLABLE BBYAEG..HANGUL SYLLABLE BBYAEH - {0xBED0, 0xBED0, prLV}, // Lo HANGUL SYLLABLE BBEO - {0xBED1, 0xBEEB, prLVT}, // Lo [27] HANGUL SYLLABLE BBEOG..HANGUL SYLLABLE BBEOH - {0xBEEC, 0xBEEC, prLV}, // Lo HANGUL SYLLABLE BBE - {0xBEED, 0xBF07, prLVT}, // Lo [27] HANGUL SYLLABLE BBEG..HANGUL SYLLABLE BBEH - {0xBF08, 0xBF08, prLV}, // Lo HANGUL SYLLABLE BBYEO - {0xBF09, 0xBF23, prLVT}, // Lo [27] HANGUL SYLLABLE BBYEOG..HANGUL SYLLABLE BBYEOH - {0xBF24, 0xBF24, prLV}, // Lo HANGUL SYLLABLE BBYE - {0xBF25, 0xBF3F, prLVT}, // Lo [27] HANGUL SYLLABLE BBYEG..HANGUL SYLLABLE BBYEH - {0xBF40, 0xBF40, prLV}, // Lo HANGUL SYLLABLE BBO - {0xBF41, 0xBF5B, prLVT}, // Lo [27] HANGUL SYLLABLE BBOG..HANGUL SYLLABLE BBOH - {0xBF5C, 0xBF5C, prLV}, // Lo HANGUL SYLLABLE BBWA - {0xBF5D, 0xBF77, prLVT}, // Lo [27] HANGUL SYLLABLE BBWAG..HANGUL SYLLABLE BBWAH - {0xBF78, 0xBF78, prLV}, // Lo HANGUL SYLLABLE BBWAE - {0xBF79, 0xBF93, prLVT}, // Lo [27] HANGUL SYLLABLE BBWAEG..HANGUL SYLLABLE BBWAEH - {0xBF94, 0xBF94, prLV}, // Lo HANGUL SYLLABLE BBOE - {0xBF95, 0xBFAF, prLVT}, // Lo [27] HANGUL SYLLABLE BBOEG..HANGUL SYLLABLE BBOEH - {0xBFB0, 0xBFB0, prLV}, // Lo HANGUL SYLLABLE BBYO - {0xBFB1, 0xBFCB, prLVT}, // Lo [27] HANGUL SYLLABLE BBYOG..HANGUL SYLLABLE BBYOH - {0xBFCC, 0xBFCC, prLV}, // Lo HANGUL SYLLABLE BBU - {0xBFCD, 0xBFE7, prLVT}, // Lo [27] HANGUL SYLLABLE BBUG..HANGUL SYLLABLE BBUH - {0xBFE8, 0xBFE8, prLV}, // Lo HANGUL SYLLABLE BBWEO - {0xBFE9, 0xC003, prLVT}, // Lo [27] HANGUL SYLLABLE BBWEOG..HANGUL SYLLABLE BBWEOH - {0xC004, 0xC004, prLV}, // Lo HANGUL SYLLABLE BBWE - {0xC005, 0xC01F, prLVT}, // Lo [27] HANGUL SYLLABLE BBWEG..HANGUL SYLLABLE BBWEH - {0xC020, 0xC020, prLV}, // Lo HANGUL SYLLABLE BBWI - {0xC021, 0xC03B, prLVT}, // Lo [27] HANGUL SYLLABLE BBWIG..HANGUL SYLLABLE BBWIH - {0xC03C, 0xC03C, prLV}, // Lo HANGUL SYLLABLE BBYU - {0xC03D, 0xC057, prLVT}, // Lo [27] HANGUL SYLLABLE BBYUG..HANGUL SYLLABLE BBYUH - {0xC058, 0xC058, prLV}, // Lo HANGUL SYLLABLE BBEU - {0xC059, 0xC073, prLVT}, // Lo [27] HANGUL SYLLABLE BBEUG..HANGUL SYLLABLE BBEUH - {0xC074, 0xC074, prLV}, // Lo HANGUL SYLLABLE BBYI - {0xC075, 0xC08F, prLVT}, // Lo [27] HANGUL SYLLABLE BBYIG..HANGUL SYLLABLE BBYIH - {0xC090, 0xC090, prLV}, // Lo HANGUL SYLLABLE BBI - {0xC091, 0xC0AB, prLVT}, // Lo [27] HANGUL SYLLABLE BBIG..HANGUL SYLLABLE BBIH - {0xC0AC, 0xC0AC, prLV}, // Lo HANGUL SYLLABLE SA - {0xC0AD, 0xC0C7, prLVT}, // Lo [27] HANGUL SYLLABLE SAG..HANGUL SYLLABLE SAH - {0xC0C8, 0xC0C8, prLV}, // Lo HANGUL SYLLABLE SAE - {0xC0C9, 0xC0E3, prLVT}, // Lo [27] HANGUL SYLLABLE SAEG..HANGUL SYLLABLE SAEH - {0xC0E4, 0xC0E4, prLV}, // Lo HANGUL SYLLABLE SYA - {0xC0E5, 0xC0FF, prLVT}, // Lo [27] HANGUL SYLLABLE SYAG..HANGUL SYLLABLE SYAH - {0xC100, 0xC100, prLV}, // Lo HANGUL SYLLABLE SYAE - {0xC101, 0xC11B, prLVT}, // Lo [27] HANGUL SYLLABLE SYAEG..HANGUL SYLLABLE SYAEH - {0xC11C, 0xC11C, prLV}, // Lo HANGUL SYLLABLE SEO - {0xC11D, 0xC137, prLVT}, // Lo [27] HANGUL SYLLABLE SEOG..HANGUL SYLLABLE SEOH - {0xC138, 0xC138, prLV}, // Lo HANGUL SYLLABLE SE - {0xC139, 0xC153, prLVT}, // Lo [27] HANGUL SYLLABLE SEG..HANGUL SYLLABLE SEH - {0xC154, 0xC154, prLV}, // Lo HANGUL SYLLABLE SYEO - {0xC155, 0xC16F, prLVT}, // Lo [27] HANGUL SYLLABLE SYEOG..HANGUL SYLLABLE SYEOH - {0xC170, 0xC170, prLV}, // Lo HANGUL SYLLABLE SYE - {0xC171, 0xC18B, prLVT}, // Lo [27] HANGUL SYLLABLE SYEG..HANGUL SYLLABLE SYEH - {0xC18C, 0xC18C, prLV}, // Lo HANGUL SYLLABLE SO - {0xC18D, 0xC1A7, prLVT}, // Lo [27] HANGUL SYLLABLE SOG..HANGUL SYLLABLE SOH - {0xC1A8, 0xC1A8, prLV}, // Lo HANGUL SYLLABLE SWA - {0xC1A9, 0xC1C3, prLVT}, // Lo [27] HANGUL SYLLABLE SWAG..HANGUL SYLLABLE SWAH - {0xC1C4, 0xC1C4, prLV}, // Lo HANGUL SYLLABLE SWAE - {0xC1C5, 0xC1DF, prLVT}, // Lo [27] HANGUL SYLLABLE SWAEG..HANGUL SYLLABLE SWAEH - {0xC1E0, 0xC1E0, prLV}, // Lo HANGUL SYLLABLE SOE - {0xC1E1, 0xC1FB, prLVT}, // Lo [27] HANGUL SYLLABLE SOEG..HANGUL SYLLABLE SOEH - {0xC1FC, 0xC1FC, prLV}, // Lo HANGUL SYLLABLE SYO - {0xC1FD, 0xC217, prLVT}, // Lo [27] HANGUL SYLLABLE SYOG..HANGUL SYLLABLE SYOH - {0xC218, 0xC218, prLV}, // Lo HANGUL SYLLABLE SU - {0xC219, 0xC233, prLVT}, // Lo [27] HANGUL SYLLABLE SUG..HANGUL SYLLABLE SUH - {0xC234, 0xC234, prLV}, // Lo HANGUL SYLLABLE SWEO - {0xC235, 0xC24F, prLVT}, // Lo [27] HANGUL SYLLABLE SWEOG..HANGUL SYLLABLE SWEOH - {0xC250, 0xC250, prLV}, // Lo HANGUL SYLLABLE SWE - {0xC251, 0xC26B, prLVT}, // Lo [27] HANGUL SYLLABLE SWEG..HANGUL SYLLABLE SWEH - {0xC26C, 0xC26C, prLV}, // Lo HANGUL SYLLABLE SWI - {0xC26D, 0xC287, prLVT}, // Lo [27] HANGUL SYLLABLE SWIG..HANGUL SYLLABLE SWIH - {0xC288, 0xC288, prLV}, // Lo HANGUL SYLLABLE SYU - {0xC289, 0xC2A3, prLVT}, // Lo [27] HANGUL SYLLABLE SYUG..HANGUL SYLLABLE SYUH - {0xC2A4, 0xC2A4, prLV}, // Lo HANGUL SYLLABLE SEU - {0xC2A5, 0xC2BF, prLVT}, // Lo [27] HANGUL SYLLABLE SEUG..HANGUL SYLLABLE SEUH - {0xC2C0, 0xC2C0, prLV}, // Lo HANGUL SYLLABLE SYI - {0xC2C1, 0xC2DB, prLVT}, // Lo [27] HANGUL SYLLABLE SYIG..HANGUL SYLLABLE SYIH - {0xC2DC, 0xC2DC, prLV}, // Lo HANGUL SYLLABLE SI - {0xC2DD, 0xC2F7, prLVT}, // Lo [27] HANGUL SYLLABLE SIG..HANGUL SYLLABLE SIH - {0xC2F8, 0xC2F8, prLV}, // Lo HANGUL SYLLABLE SSA - {0xC2F9, 0xC313, prLVT}, // Lo [27] HANGUL SYLLABLE SSAG..HANGUL SYLLABLE SSAH - {0xC314, 0xC314, prLV}, // Lo HANGUL SYLLABLE SSAE - {0xC315, 0xC32F, prLVT}, // Lo [27] HANGUL SYLLABLE SSAEG..HANGUL SYLLABLE SSAEH - {0xC330, 0xC330, prLV}, // Lo HANGUL SYLLABLE SSYA - {0xC331, 0xC34B, prLVT}, // Lo [27] HANGUL SYLLABLE SSYAG..HANGUL SYLLABLE SSYAH - {0xC34C, 0xC34C, prLV}, // Lo HANGUL SYLLABLE SSYAE - {0xC34D, 0xC367, prLVT}, // Lo [27] HANGUL SYLLABLE SSYAEG..HANGUL SYLLABLE SSYAEH - {0xC368, 0xC368, prLV}, // Lo HANGUL SYLLABLE SSEO - {0xC369, 0xC383, prLVT}, // Lo [27] HANGUL SYLLABLE SSEOG..HANGUL SYLLABLE SSEOH - {0xC384, 0xC384, prLV}, // Lo HANGUL SYLLABLE SSE - {0xC385, 0xC39F, prLVT}, // Lo [27] HANGUL SYLLABLE SSEG..HANGUL SYLLABLE SSEH - {0xC3A0, 0xC3A0, prLV}, // Lo HANGUL SYLLABLE SSYEO - {0xC3A1, 0xC3BB, prLVT}, // Lo [27] HANGUL SYLLABLE SSYEOG..HANGUL SYLLABLE SSYEOH - {0xC3BC, 0xC3BC, prLV}, // Lo HANGUL SYLLABLE SSYE - {0xC3BD, 0xC3D7, prLVT}, // Lo [27] HANGUL SYLLABLE SSYEG..HANGUL SYLLABLE SSYEH - {0xC3D8, 0xC3D8, prLV}, // Lo HANGUL SYLLABLE SSO - {0xC3D9, 0xC3F3, prLVT}, // Lo [27] HANGUL SYLLABLE SSOG..HANGUL SYLLABLE SSOH - {0xC3F4, 0xC3F4, prLV}, // Lo HANGUL SYLLABLE SSWA - {0xC3F5, 0xC40F, prLVT}, // Lo [27] HANGUL SYLLABLE SSWAG..HANGUL SYLLABLE SSWAH - {0xC410, 0xC410, prLV}, // Lo HANGUL SYLLABLE SSWAE - {0xC411, 0xC42B, prLVT}, // Lo [27] HANGUL SYLLABLE SSWAEG..HANGUL SYLLABLE SSWAEH - {0xC42C, 0xC42C, prLV}, // Lo HANGUL SYLLABLE SSOE - {0xC42D, 0xC447, prLVT}, // Lo [27] HANGUL SYLLABLE SSOEG..HANGUL SYLLABLE SSOEH - {0xC448, 0xC448, prLV}, // Lo HANGUL SYLLABLE SSYO - {0xC449, 0xC463, prLVT}, // Lo [27] HANGUL SYLLABLE SSYOG..HANGUL SYLLABLE SSYOH - {0xC464, 0xC464, prLV}, // Lo HANGUL SYLLABLE SSU - {0xC465, 0xC47F, prLVT}, // Lo [27] HANGUL SYLLABLE SSUG..HANGUL SYLLABLE SSUH - {0xC480, 0xC480, prLV}, // Lo HANGUL SYLLABLE SSWEO - {0xC481, 0xC49B, prLVT}, // Lo [27] HANGUL SYLLABLE SSWEOG..HANGUL SYLLABLE SSWEOH - {0xC49C, 0xC49C, prLV}, // Lo HANGUL SYLLABLE SSWE - {0xC49D, 0xC4B7, prLVT}, // Lo [27] HANGUL SYLLABLE SSWEG..HANGUL SYLLABLE SSWEH - {0xC4B8, 0xC4B8, prLV}, // Lo HANGUL SYLLABLE SSWI - {0xC4B9, 0xC4D3, prLVT}, // Lo [27] HANGUL SYLLABLE SSWIG..HANGUL SYLLABLE SSWIH - {0xC4D4, 0xC4D4, prLV}, // Lo HANGUL SYLLABLE SSYU - {0xC4D5, 0xC4EF, prLVT}, // Lo [27] HANGUL SYLLABLE SSYUG..HANGUL SYLLABLE SSYUH - {0xC4F0, 0xC4F0, prLV}, // Lo HANGUL SYLLABLE SSEU - {0xC4F1, 0xC50B, prLVT}, // Lo [27] HANGUL SYLLABLE SSEUG..HANGUL SYLLABLE SSEUH - {0xC50C, 0xC50C, prLV}, // Lo HANGUL SYLLABLE SSYI - {0xC50D, 0xC527, prLVT}, // Lo [27] HANGUL SYLLABLE SSYIG..HANGUL SYLLABLE SSYIH - {0xC528, 0xC528, prLV}, // Lo HANGUL SYLLABLE SSI - {0xC529, 0xC543, prLVT}, // Lo [27] HANGUL SYLLABLE SSIG..HANGUL SYLLABLE SSIH - {0xC544, 0xC544, prLV}, // Lo HANGUL SYLLABLE A - {0xC545, 0xC55F, prLVT}, // Lo [27] HANGUL SYLLABLE AG..HANGUL SYLLABLE AH - {0xC560, 0xC560, prLV}, // Lo HANGUL SYLLABLE AE - {0xC561, 0xC57B, prLVT}, // Lo [27] HANGUL SYLLABLE AEG..HANGUL SYLLABLE AEH - {0xC57C, 0xC57C, prLV}, // Lo HANGUL SYLLABLE YA - {0xC57D, 0xC597, prLVT}, // Lo [27] HANGUL SYLLABLE YAG..HANGUL SYLLABLE YAH - {0xC598, 0xC598, prLV}, // Lo HANGUL SYLLABLE YAE - {0xC599, 0xC5B3, prLVT}, // Lo [27] HANGUL SYLLABLE YAEG..HANGUL SYLLABLE YAEH - {0xC5B4, 0xC5B4, prLV}, // Lo HANGUL SYLLABLE EO - {0xC5B5, 0xC5CF, prLVT}, // Lo [27] HANGUL SYLLABLE EOG..HANGUL SYLLABLE EOH - {0xC5D0, 0xC5D0, prLV}, // Lo HANGUL SYLLABLE E - {0xC5D1, 0xC5EB, prLVT}, // Lo [27] HANGUL SYLLABLE EG..HANGUL SYLLABLE EH - {0xC5EC, 0xC5EC, prLV}, // Lo HANGUL SYLLABLE YEO - {0xC5ED, 0xC607, prLVT}, // Lo [27] HANGUL SYLLABLE YEOG..HANGUL SYLLABLE YEOH - {0xC608, 0xC608, prLV}, // Lo HANGUL SYLLABLE YE - {0xC609, 0xC623, prLVT}, // Lo [27] HANGUL SYLLABLE YEG..HANGUL SYLLABLE YEH - {0xC624, 0xC624, prLV}, // Lo HANGUL SYLLABLE O - {0xC625, 0xC63F, prLVT}, // Lo [27] HANGUL SYLLABLE OG..HANGUL SYLLABLE OH - {0xC640, 0xC640, prLV}, // Lo HANGUL SYLLABLE WA - {0xC641, 0xC65B, prLVT}, // Lo [27] HANGUL SYLLABLE WAG..HANGUL SYLLABLE WAH - {0xC65C, 0xC65C, prLV}, // Lo HANGUL SYLLABLE WAE - {0xC65D, 0xC677, prLVT}, // Lo [27] HANGUL SYLLABLE WAEG..HANGUL SYLLABLE WAEH - {0xC678, 0xC678, prLV}, // Lo HANGUL SYLLABLE OE - {0xC679, 0xC693, prLVT}, // Lo [27] HANGUL SYLLABLE OEG..HANGUL SYLLABLE OEH - {0xC694, 0xC694, prLV}, // Lo HANGUL SYLLABLE YO - {0xC695, 0xC6AF, prLVT}, // Lo [27] HANGUL SYLLABLE YOG..HANGUL SYLLABLE YOH - {0xC6B0, 0xC6B0, prLV}, // Lo HANGUL SYLLABLE U - {0xC6B1, 0xC6CB, prLVT}, // Lo [27] HANGUL SYLLABLE UG..HANGUL SYLLABLE UH - {0xC6CC, 0xC6CC, prLV}, // Lo HANGUL SYLLABLE WEO - {0xC6CD, 0xC6E7, prLVT}, // Lo [27] HANGUL SYLLABLE WEOG..HANGUL SYLLABLE WEOH - {0xC6E8, 0xC6E8, prLV}, // Lo HANGUL SYLLABLE WE - {0xC6E9, 0xC703, prLVT}, // Lo [27] HANGUL SYLLABLE WEG..HANGUL SYLLABLE WEH - {0xC704, 0xC704, prLV}, // Lo HANGUL SYLLABLE WI - {0xC705, 0xC71F, prLVT}, // Lo [27] HANGUL SYLLABLE WIG..HANGUL SYLLABLE WIH - {0xC720, 0xC720, prLV}, // Lo HANGUL SYLLABLE YU - {0xC721, 0xC73B, prLVT}, // Lo [27] HANGUL SYLLABLE YUG..HANGUL SYLLABLE YUH - {0xC73C, 0xC73C, prLV}, // Lo HANGUL SYLLABLE EU - {0xC73D, 0xC757, prLVT}, // Lo [27] HANGUL SYLLABLE EUG..HANGUL SYLLABLE EUH - {0xC758, 0xC758, prLV}, // Lo HANGUL SYLLABLE YI - {0xC759, 0xC773, prLVT}, // Lo [27] HANGUL SYLLABLE YIG..HANGUL SYLLABLE YIH - {0xC774, 0xC774, prLV}, // Lo HANGUL SYLLABLE I - {0xC775, 0xC78F, prLVT}, // Lo [27] HANGUL SYLLABLE IG..HANGUL SYLLABLE IH - {0xC790, 0xC790, prLV}, // Lo HANGUL SYLLABLE JA - {0xC791, 0xC7AB, prLVT}, // Lo [27] HANGUL SYLLABLE JAG..HANGUL SYLLABLE JAH - {0xC7AC, 0xC7AC, prLV}, // Lo HANGUL SYLLABLE JAE - {0xC7AD, 0xC7C7, prLVT}, // Lo [27] HANGUL SYLLABLE JAEG..HANGUL SYLLABLE JAEH - {0xC7C8, 0xC7C8, prLV}, // Lo HANGUL SYLLABLE JYA - {0xC7C9, 0xC7E3, prLVT}, // Lo [27] HANGUL SYLLABLE JYAG..HANGUL SYLLABLE JYAH - {0xC7E4, 0xC7E4, prLV}, // Lo HANGUL SYLLABLE JYAE - {0xC7E5, 0xC7FF, prLVT}, // Lo [27] HANGUL SYLLABLE JYAEG..HANGUL SYLLABLE JYAEH - {0xC800, 0xC800, prLV}, // Lo HANGUL SYLLABLE JEO - {0xC801, 0xC81B, prLVT}, // Lo [27] HANGUL SYLLABLE JEOG..HANGUL SYLLABLE JEOH - {0xC81C, 0xC81C, prLV}, // Lo HANGUL SYLLABLE JE - {0xC81D, 0xC837, prLVT}, // Lo [27] HANGUL SYLLABLE JEG..HANGUL SYLLABLE JEH - {0xC838, 0xC838, prLV}, // Lo HANGUL SYLLABLE JYEO - {0xC839, 0xC853, prLVT}, // Lo [27] HANGUL SYLLABLE JYEOG..HANGUL SYLLABLE JYEOH - {0xC854, 0xC854, prLV}, // Lo HANGUL SYLLABLE JYE - {0xC855, 0xC86F, prLVT}, // Lo [27] HANGUL SYLLABLE JYEG..HANGUL SYLLABLE JYEH - {0xC870, 0xC870, prLV}, // Lo HANGUL SYLLABLE JO - {0xC871, 0xC88B, prLVT}, // Lo [27] HANGUL SYLLABLE JOG..HANGUL SYLLABLE JOH - {0xC88C, 0xC88C, prLV}, // Lo HANGUL SYLLABLE JWA - {0xC88D, 0xC8A7, prLVT}, // Lo [27] HANGUL SYLLABLE JWAG..HANGUL SYLLABLE JWAH - {0xC8A8, 0xC8A8, prLV}, // Lo HANGUL SYLLABLE JWAE - {0xC8A9, 0xC8C3, prLVT}, // Lo [27] HANGUL SYLLABLE JWAEG..HANGUL SYLLABLE JWAEH - {0xC8C4, 0xC8C4, prLV}, // Lo HANGUL SYLLABLE JOE - {0xC8C5, 0xC8DF, prLVT}, // Lo [27] HANGUL SYLLABLE JOEG..HANGUL SYLLABLE JOEH - {0xC8E0, 0xC8E0, prLV}, // Lo HANGUL SYLLABLE JYO - {0xC8E1, 0xC8FB, prLVT}, // Lo [27] HANGUL SYLLABLE JYOG..HANGUL SYLLABLE JYOH - {0xC8FC, 0xC8FC, prLV}, // Lo HANGUL SYLLABLE JU - {0xC8FD, 0xC917, prLVT}, // Lo [27] HANGUL SYLLABLE JUG..HANGUL SYLLABLE JUH - {0xC918, 0xC918, prLV}, // Lo HANGUL SYLLABLE JWEO - {0xC919, 0xC933, prLVT}, // Lo [27] HANGUL SYLLABLE JWEOG..HANGUL SYLLABLE JWEOH - {0xC934, 0xC934, prLV}, // Lo HANGUL SYLLABLE JWE - {0xC935, 0xC94F, prLVT}, // Lo [27] HANGUL SYLLABLE JWEG..HANGUL SYLLABLE JWEH - {0xC950, 0xC950, prLV}, // Lo HANGUL SYLLABLE JWI - {0xC951, 0xC96B, prLVT}, // Lo [27] HANGUL SYLLABLE JWIG..HANGUL SYLLABLE JWIH - {0xC96C, 0xC96C, prLV}, // Lo HANGUL SYLLABLE JYU - {0xC96D, 0xC987, prLVT}, // Lo [27] HANGUL SYLLABLE JYUG..HANGUL SYLLABLE JYUH - {0xC988, 0xC988, prLV}, // Lo HANGUL SYLLABLE JEU - {0xC989, 0xC9A3, prLVT}, // Lo [27] HANGUL SYLLABLE JEUG..HANGUL SYLLABLE JEUH - {0xC9A4, 0xC9A4, prLV}, // Lo HANGUL SYLLABLE JYI - {0xC9A5, 0xC9BF, prLVT}, // Lo [27] HANGUL SYLLABLE JYIG..HANGUL SYLLABLE JYIH - {0xC9C0, 0xC9C0, prLV}, // Lo HANGUL SYLLABLE JI - {0xC9C1, 0xC9DB, prLVT}, // Lo [27] HANGUL SYLLABLE JIG..HANGUL SYLLABLE JIH - {0xC9DC, 0xC9DC, prLV}, // Lo HANGUL SYLLABLE JJA - {0xC9DD, 0xC9F7, prLVT}, // Lo [27] HANGUL SYLLABLE JJAG..HANGUL SYLLABLE JJAH - {0xC9F8, 0xC9F8, prLV}, // Lo HANGUL SYLLABLE JJAE - {0xC9F9, 0xCA13, prLVT}, // Lo [27] HANGUL SYLLABLE JJAEG..HANGUL SYLLABLE JJAEH - {0xCA14, 0xCA14, prLV}, // Lo HANGUL SYLLABLE JJYA - {0xCA15, 0xCA2F, prLVT}, // Lo [27] HANGUL SYLLABLE JJYAG..HANGUL SYLLABLE JJYAH - {0xCA30, 0xCA30, prLV}, // Lo HANGUL SYLLABLE JJYAE - {0xCA31, 0xCA4B, prLVT}, // Lo [27] HANGUL SYLLABLE JJYAEG..HANGUL SYLLABLE JJYAEH - {0xCA4C, 0xCA4C, prLV}, // Lo HANGUL SYLLABLE JJEO - {0xCA4D, 0xCA67, prLVT}, // Lo [27] HANGUL SYLLABLE JJEOG..HANGUL SYLLABLE JJEOH - {0xCA68, 0xCA68, prLV}, // Lo HANGUL SYLLABLE JJE - {0xCA69, 0xCA83, prLVT}, // Lo [27] HANGUL SYLLABLE JJEG..HANGUL SYLLABLE JJEH - {0xCA84, 0xCA84, prLV}, // Lo HANGUL SYLLABLE JJYEO - {0xCA85, 0xCA9F, prLVT}, // Lo [27] HANGUL SYLLABLE JJYEOG..HANGUL SYLLABLE JJYEOH - {0xCAA0, 0xCAA0, prLV}, // Lo HANGUL SYLLABLE JJYE - {0xCAA1, 0xCABB, prLVT}, // Lo [27] HANGUL SYLLABLE JJYEG..HANGUL SYLLABLE JJYEH - {0xCABC, 0xCABC, prLV}, // Lo HANGUL SYLLABLE JJO - {0xCABD, 0xCAD7, prLVT}, // Lo [27] HANGUL SYLLABLE JJOG..HANGUL SYLLABLE JJOH - {0xCAD8, 0xCAD8, prLV}, // Lo HANGUL SYLLABLE JJWA - {0xCAD9, 0xCAF3, prLVT}, // Lo [27] HANGUL SYLLABLE JJWAG..HANGUL SYLLABLE JJWAH - {0xCAF4, 0xCAF4, prLV}, // Lo HANGUL SYLLABLE JJWAE - {0xCAF5, 0xCB0F, prLVT}, // Lo [27] HANGUL SYLLABLE JJWAEG..HANGUL SYLLABLE JJWAEH - {0xCB10, 0xCB10, prLV}, // Lo HANGUL SYLLABLE JJOE - {0xCB11, 0xCB2B, prLVT}, // Lo [27] HANGUL SYLLABLE JJOEG..HANGUL SYLLABLE JJOEH - {0xCB2C, 0xCB2C, prLV}, // Lo HANGUL SYLLABLE JJYO - {0xCB2D, 0xCB47, prLVT}, // Lo [27] HANGUL SYLLABLE JJYOG..HANGUL SYLLABLE JJYOH - {0xCB48, 0xCB48, prLV}, // Lo HANGUL SYLLABLE JJU - {0xCB49, 0xCB63, prLVT}, // Lo [27] HANGUL SYLLABLE JJUG..HANGUL SYLLABLE JJUH - {0xCB64, 0xCB64, prLV}, // Lo HANGUL SYLLABLE JJWEO - {0xCB65, 0xCB7F, prLVT}, // Lo [27] HANGUL SYLLABLE JJWEOG..HANGUL SYLLABLE JJWEOH - {0xCB80, 0xCB80, prLV}, // Lo HANGUL SYLLABLE JJWE - {0xCB81, 0xCB9B, prLVT}, // Lo [27] HANGUL SYLLABLE JJWEG..HANGUL SYLLABLE JJWEH - {0xCB9C, 0xCB9C, prLV}, // Lo HANGUL SYLLABLE JJWI - {0xCB9D, 0xCBB7, prLVT}, // Lo [27] HANGUL SYLLABLE JJWIG..HANGUL SYLLABLE JJWIH - {0xCBB8, 0xCBB8, prLV}, // Lo HANGUL SYLLABLE JJYU - {0xCBB9, 0xCBD3, prLVT}, // Lo [27] HANGUL SYLLABLE JJYUG..HANGUL SYLLABLE JJYUH - {0xCBD4, 0xCBD4, prLV}, // Lo HANGUL SYLLABLE JJEU - {0xCBD5, 0xCBEF, prLVT}, // Lo [27] HANGUL SYLLABLE JJEUG..HANGUL SYLLABLE JJEUH - {0xCBF0, 0xCBF0, prLV}, // Lo HANGUL SYLLABLE JJYI - {0xCBF1, 0xCC0B, prLVT}, // Lo [27] HANGUL SYLLABLE JJYIG..HANGUL SYLLABLE JJYIH - {0xCC0C, 0xCC0C, prLV}, // Lo HANGUL SYLLABLE JJI - {0xCC0D, 0xCC27, prLVT}, // Lo [27] HANGUL SYLLABLE JJIG..HANGUL SYLLABLE JJIH - {0xCC28, 0xCC28, prLV}, // Lo HANGUL SYLLABLE CA - {0xCC29, 0xCC43, prLVT}, // Lo [27] HANGUL SYLLABLE CAG..HANGUL SYLLABLE CAH - {0xCC44, 0xCC44, prLV}, // Lo HANGUL SYLLABLE CAE - {0xCC45, 0xCC5F, prLVT}, // Lo [27] HANGUL SYLLABLE CAEG..HANGUL SYLLABLE CAEH - {0xCC60, 0xCC60, prLV}, // Lo HANGUL SYLLABLE CYA - {0xCC61, 0xCC7B, prLVT}, // Lo [27] HANGUL SYLLABLE CYAG..HANGUL SYLLABLE CYAH - {0xCC7C, 0xCC7C, prLV}, // Lo HANGUL SYLLABLE CYAE - {0xCC7D, 0xCC97, prLVT}, // Lo [27] HANGUL SYLLABLE CYAEG..HANGUL SYLLABLE CYAEH - {0xCC98, 0xCC98, prLV}, // Lo HANGUL SYLLABLE CEO - {0xCC99, 0xCCB3, prLVT}, // Lo [27] HANGUL SYLLABLE CEOG..HANGUL SYLLABLE CEOH - {0xCCB4, 0xCCB4, prLV}, // Lo HANGUL SYLLABLE CE - {0xCCB5, 0xCCCF, prLVT}, // Lo [27] HANGUL SYLLABLE CEG..HANGUL SYLLABLE CEH - {0xCCD0, 0xCCD0, prLV}, // Lo HANGUL SYLLABLE CYEO - {0xCCD1, 0xCCEB, prLVT}, // Lo [27] HANGUL SYLLABLE CYEOG..HANGUL SYLLABLE CYEOH - {0xCCEC, 0xCCEC, prLV}, // Lo HANGUL SYLLABLE CYE - {0xCCED, 0xCD07, prLVT}, // Lo [27] HANGUL SYLLABLE CYEG..HANGUL SYLLABLE CYEH - {0xCD08, 0xCD08, prLV}, // Lo HANGUL SYLLABLE CO - {0xCD09, 0xCD23, prLVT}, // Lo [27] HANGUL SYLLABLE COG..HANGUL SYLLABLE COH - {0xCD24, 0xCD24, prLV}, // Lo HANGUL SYLLABLE CWA - {0xCD25, 0xCD3F, prLVT}, // Lo [27] HANGUL SYLLABLE CWAG..HANGUL SYLLABLE CWAH - {0xCD40, 0xCD40, prLV}, // Lo HANGUL SYLLABLE CWAE - {0xCD41, 0xCD5B, prLVT}, // Lo [27] HANGUL SYLLABLE CWAEG..HANGUL SYLLABLE CWAEH - {0xCD5C, 0xCD5C, prLV}, // Lo HANGUL SYLLABLE COE - {0xCD5D, 0xCD77, prLVT}, // Lo [27] HANGUL SYLLABLE COEG..HANGUL SYLLABLE COEH - {0xCD78, 0xCD78, prLV}, // Lo HANGUL SYLLABLE CYO - {0xCD79, 0xCD93, prLVT}, // Lo [27] HANGUL SYLLABLE CYOG..HANGUL SYLLABLE CYOH - {0xCD94, 0xCD94, prLV}, // Lo HANGUL SYLLABLE CU - {0xCD95, 0xCDAF, prLVT}, // Lo [27] HANGUL SYLLABLE CUG..HANGUL SYLLABLE CUH - {0xCDB0, 0xCDB0, prLV}, // Lo HANGUL SYLLABLE CWEO - {0xCDB1, 0xCDCB, prLVT}, // Lo [27] HANGUL SYLLABLE CWEOG..HANGUL SYLLABLE CWEOH - {0xCDCC, 0xCDCC, prLV}, // Lo HANGUL SYLLABLE CWE - {0xCDCD, 0xCDE7, prLVT}, // Lo [27] HANGUL SYLLABLE CWEG..HANGUL SYLLABLE CWEH - {0xCDE8, 0xCDE8, prLV}, // Lo HANGUL SYLLABLE CWI - {0xCDE9, 0xCE03, prLVT}, // Lo [27] HANGUL SYLLABLE CWIG..HANGUL SYLLABLE CWIH - {0xCE04, 0xCE04, prLV}, // Lo HANGUL SYLLABLE CYU - {0xCE05, 0xCE1F, prLVT}, // Lo [27] HANGUL SYLLABLE CYUG..HANGUL SYLLABLE CYUH - {0xCE20, 0xCE20, prLV}, // Lo HANGUL SYLLABLE CEU - {0xCE21, 0xCE3B, prLVT}, // Lo [27] HANGUL SYLLABLE CEUG..HANGUL SYLLABLE CEUH - {0xCE3C, 0xCE3C, prLV}, // Lo HANGUL SYLLABLE CYI - {0xCE3D, 0xCE57, prLVT}, // Lo [27] HANGUL SYLLABLE CYIG..HANGUL SYLLABLE CYIH - {0xCE58, 0xCE58, prLV}, // Lo HANGUL SYLLABLE CI - {0xCE59, 0xCE73, prLVT}, // Lo [27] HANGUL SYLLABLE CIG..HANGUL SYLLABLE CIH - {0xCE74, 0xCE74, prLV}, // Lo HANGUL SYLLABLE KA - {0xCE75, 0xCE8F, prLVT}, // Lo [27] HANGUL SYLLABLE KAG..HANGUL SYLLABLE KAH - {0xCE90, 0xCE90, prLV}, // Lo HANGUL SYLLABLE KAE - {0xCE91, 0xCEAB, prLVT}, // Lo [27] HANGUL SYLLABLE KAEG..HANGUL SYLLABLE KAEH - {0xCEAC, 0xCEAC, prLV}, // Lo HANGUL SYLLABLE KYA - {0xCEAD, 0xCEC7, prLVT}, // Lo [27] HANGUL SYLLABLE KYAG..HANGUL SYLLABLE KYAH - {0xCEC8, 0xCEC8, prLV}, // Lo HANGUL SYLLABLE KYAE - {0xCEC9, 0xCEE3, prLVT}, // Lo [27] HANGUL SYLLABLE KYAEG..HANGUL SYLLABLE KYAEH - {0xCEE4, 0xCEE4, prLV}, // Lo HANGUL SYLLABLE KEO - {0xCEE5, 0xCEFF, prLVT}, // Lo [27] HANGUL SYLLABLE KEOG..HANGUL SYLLABLE KEOH - {0xCF00, 0xCF00, prLV}, // Lo HANGUL SYLLABLE KE - {0xCF01, 0xCF1B, prLVT}, // Lo [27] HANGUL SYLLABLE KEG..HANGUL SYLLABLE KEH - {0xCF1C, 0xCF1C, prLV}, // Lo HANGUL SYLLABLE KYEO - {0xCF1D, 0xCF37, prLVT}, // Lo [27] HANGUL SYLLABLE KYEOG..HANGUL SYLLABLE KYEOH - {0xCF38, 0xCF38, prLV}, // Lo HANGUL SYLLABLE KYE - {0xCF39, 0xCF53, prLVT}, // Lo [27] HANGUL SYLLABLE KYEG..HANGUL SYLLABLE KYEH - {0xCF54, 0xCF54, prLV}, // Lo HANGUL SYLLABLE KO - {0xCF55, 0xCF6F, prLVT}, // Lo [27] HANGUL SYLLABLE KOG..HANGUL SYLLABLE KOH - {0xCF70, 0xCF70, prLV}, // Lo HANGUL SYLLABLE KWA - {0xCF71, 0xCF8B, prLVT}, // Lo [27] HANGUL SYLLABLE KWAG..HANGUL SYLLABLE KWAH - {0xCF8C, 0xCF8C, prLV}, // Lo HANGUL SYLLABLE KWAE - {0xCF8D, 0xCFA7, prLVT}, // Lo [27] HANGUL SYLLABLE KWAEG..HANGUL SYLLABLE KWAEH - {0xCFA8, 0xCFA8, prLV}, // Lo HANGUL SYLLABLE KOE - {0xCFA9, 0xCFC3, prLVT}, // Lo [27] HANGUL SYLLABLE KOEG..HANGUL SYLLABLE KOEH - {0xCFC4, 0xCFC4, prLV}, // Lo HANGUL SYLLABLE KYO - {0xCFC5, 0xCFDF, prLVT}, // Lo [27] HANGUL SYLLABLE KYOG..HANGUL SYLLABLE KYOH - {0xCFE0, 0xCFE0, prLV}, // Lo HANGUL SYLLABLE KU - {0xCFE1, 0xCFFB, prLVT}, // Lo [27] HANGUL SYLLABLE KUG..HANGUL SYLLABLE KUH - {0xCFFC, 0xCFFC, prLV}, // Lo HANGUL SYLLABLE KWEO - {0xCFFD, 0xD017, prLVT}, // Lo [27] HANGUL SYLLABLE KWEOG..HANGUL SYLLABLE KWEOH - {0xD018, 0xD018, prLV}, // Lo HANGUL SYLLABLE KWE - {0xD019, 0xD033, prLVT}, // Lo [27] HANGUL SYLLABLE KWEG..HANGUL SYLLABLE KWEH - {0xD034, 0xD034, prLV}, // Lo HANGUL SYLLABLE KWI - {0xD035, 0xD04F, prLVT}, // Lo [27] HANGUL SYLLABLE KWIG..HANGUL SYLLABLE KWIH - {0xD050, 0xD050, prLV}, // Lo HANGUL SYLLABLE KYU - {0xD051, 0xD06B, prLVT}, // Lo [27] HANGUL SYLLABLE KYUG..HANGUL SYLLABLE KYUH - {0xD06C, 0xD06C, prLV}, // Lo HANGUL SYLLABLE KEU - {0xD06D, 0xD087, prLVT}, // Lo [27] HANGUL SYLLABLE KEUG..HANGUL SYLLABLE KEUH - {0xD088, 0xD088, prLV}, // Lo HANGUL SYLLABLE KYI - {0xD089, 0xD0A3, prLVT}, // Lo [27] HANGUL SYLLABLE KYIG..HANGUL SYLLABLE KYIH - {0xD0A4, 0xD0A4, prLV}, // Lo HANGUL SYLLABLE KI - {0xD0A5, 0xD0BF, prLVT}, // Lo [27] HANGUL SYLLABLE KIG..HANGUL SYLLABLE KIH - {0xD0C0, 0xD0C0, prLV}, // Lo HANGUL SYLLABLE TA - {0xD0C1, 0xD0DB, prLVT}, // Lo [27] HANGUL SYLLABLE TAG..HANGUL SYLLABLE TAH - {0xD0DC, 0xD0DC, prLV}, // Lo HANGUL SYLLABLE TAE - {0xD0DD, 0xD0F7, prLVT}, // Lo [27] HANGUL SYLLABLE TAEG..HANGUL SYLLABLE TAEH - {0xD0F8, 0xD0F8, prLV}, // Lo HANGUL SYLLABLE TYA - {0xD0F9, 0xD113, prLVT}, // Lo [27] HANGUL SYLLABLE TYAG..HANGUL SYLLABLE TYAH - {0xD114, 0xD114, prLV}, // Lo HANGUL SYLLABLE TYAE - {0xD115, 0xD12F, prLVT}, // Lo [27] HANGUL SYLLABLE TYAEG..HANGUL SYLLABLE TYAEH - {0xD130, 0xD130, prLV}, // Lo HANGUL SYLLABLE TEO - {0xD131, 0xD14B, prLVT}, // Lo [27] HANGUL SYLLABLE TEOG..HANGUL SYLLABLE TEOH - {0xD14C, 0xD14C, prLV}, // Lo HANGUL SYLLABLE TE - {0xD14D, 0xD167, prLVT}, // Lo [27] HANGUL SYLLABLE TEG..HANGUL SYLLABLE TEH - {0xD168, 0xD168, prLV}, // Lo HANGUL SYLLABLE TYEO - {0xD169, 0xD183, prLVT}, // Lo [27] HANGUL SYLLABLE TYEOG..HANGUL SYLLABLE TYEOH - {0xD184, 0xD184, prLV}, // Lo HANGUL SYLLABLE TYE - {0xD185, 0xD19F, prLVT}, // Lo [27] HANGUL SYLLABLE TYEG..HANGUL SYLLABLE TYEH - {0xD1A0, 0xD1A0, prLV}, // Lo HANGUL SYLLABLE TO - {0xD1A1, 0xD1BB, prLVT}, // Lo [27] HANGUL SYLLABLE TOG..HANGUL SYLLABLE TOH - {0xD1BC, 0xD1BC, prLV}, // Lo HANGUL SYLLABLE TWA - {0xD1BD, 0xD1D7, prLVT}, // Lo [27] HANGUL SYLLABLE TWAG..HANGUL SYLLABLE TWAH - {0xD1D8, 0xD1D8, prLV}, // Lo HANGUL SYLLABLE TWAE - {0xD1D9, 0xD1F3, prLVT}, // Lo [27] HANGUL SYLLABLE TWAEG..HANGUL SYLLABLE TWAEH - {0xD1F4, 0xD1F4, prLV}, // Lo HANGUL SYLLABLE TOE - {0xD1F5, 0xD20F, prLVT}, // Lo [27] HANGUL SYLLABLE TOEG..HANGUL SYLLABLE TOEH - {0xD210, 0xD210, prLV}, // Lo HANGUL SYLLABLE TYO - {0xD211, 0xD22B, prLVT}, // Lo [27] HANGUL SYLLABLE TYOG..HANGUL SYLLABLE TYOH - {0xD22C, 0xD22C, prLV}, // Lo HANGUL SYLLABLE TU - {0xD22D, 0xD247, prLVT}, // Lo [27] HANGUL SYLLABLE TUG..HANGUL SYLLABLE TUH - {0xD248, 0xD248, prLV}, // Lo HANGUL SYLLABLE TWEO - {0xD249, 0xD263, prLVT}, // Lo [27] HANGUL SYLLABLE TWEOG..HANGUL SYLLABLE TWEOH - {0xD264, 0xD264, prLV}, // Lo HANGUL SYLLABLE TWE - {0xD265, 0xD27F, prLVT}, // Lo [27] HANGUL SYLLABLE TWEG..HANGUL SYLLABLE TWEH - {0xD280, 0xD280, prLV}, // Lo HANGUL SYLLABLE TWI - {0xD281, 0xD29B, prLVT}, // Lo [27] HANGUL SYLLABLE TWIG..HANGUL SYLLABLE TWIH - {0xD29C, 0xD29C, prLV}, // Lo HANGUL SYLLABLE TYU - {0xD29D, 0xD2B7, prLVT}, // Lo [27] HANGUL SYLLABLE TYUG..HANGUL SYLLABLE TYUH - {0xD2B8, 0xD2B8, prLV}, // Lo HANGUL SYLLABLE TEU - {0xD2B9, 0xD2D3, prLVT}, // Lo [27] HANGUL SYLLABLE TEUG..HANGUL SYLLABLE TEUH - {0xD2D4, 0xD2D4, prLV}, // Lo HANGUL SYLLABLE TYI - {0xD2D5, 0xD2EF, prLVT}, // Lo [27] HANGUL SYLLABLE TYIG..HANGUL SYLLABLE TYIH - {0xD2F0, 0xD2F0, prLV}, // Lo HANGUL SYLLABLE TI - {0xD2F1, 0xD30B, prLVT}, // Lo [27] HANGUL SYLLABLE TIG..HANGUL SYLLABLE TIH - {0xD30C, 0xD30C, prLV}, // Lo HANGUL SYLLABLE PA - {0xD30D, 0xD327, prLVT}, // Lo [27] HANGUL SYLLABLE PAG..HANGUL SYLLABLE PAH - {0xD328, 0xD328, prLV}, // Lo HANGUL SYLLABLE PAE - {0xD329, 0xD343, prLVT}, // Lo [27] HANGUL SYLLABLE PAEG..HANGUL SYLLABLE PAEH - {0xD344, 0xD344, prLV}, // Lo HANGUL SYLLABLE PYA - {0xD345, 0xD35F, prLVT}, // Lo [27] HANGUL SYLLABLE PYAG..HANGUL SYLLABLE PYAH - {0xD360, 0xD360, prLV}, // Lo HANGUL SYLLABLE PYAE - {0xD361, 0xD37B, prLVT}, // Lo [27] HANGUL SYLLABLE PYAEG..HANGUL SYLLABLE PYAEH - {0xD37C, 0xD37C, prLV}, // Lo HANGUL SYLLABLE PEO - {0xD37D, 0xD397, prLVT}, // Lo [27] HANGUL SYLLABLE PEOG..HANGUL SYLLABLE PEOH - {0xD398, 0xD398, prLV}, // Lo HANGUL SYLLABLE PE - {0xD399, 0xD3B3, prLVT}, // Lo [27] HANGUL SYLLABLE PEG..HANGUL SYLLABLE PEH - {0xD3B4, 0xD3B4, prLV}, // Lo HANGUL SYLLABLE PYEO - {0xD3B5, 0xD3CF, prLVT}, // Lo [27] HANGUL SYLLABLE PYEOG..HANGUL SYLLABLE PYEOH - {0xD3D0, 0xD3D0, prLV}, // Lo HANGUL SYLLABLE PYE - {0xD3D1, 0xD3EB, prLVT}, // Lo [27] HANGUL SYLLABLE PYEG..HANGUL SYLLABLE PYEH - {0xD3EC, 0xD3EC, prLV}, // Lo HANGUL SYLLABLE PO - {0xD3ED, 0xD407, prLVT}, // Lo [27] HANGUL SYLLABLE POG..HANGUL SYLLABLE POH - {0xD408, 0xD408, prLV}, // Lo HANGUL SYLLABLE PWA - {0xD409, 0xD423, prLVT}, // Lo [27] HANGUL SYLLABLE PWAG..HANGUL SYLLABLE PWAH - {0xD424, 0xD424, prLV}, // Lo HANGUL SYLLABLE PWAE - {0xD425, 0xD43F, prLVT}, // Lo [27] HANGUL SYLLABLE PWAEG..HANGUL SYLLABLE PWAEH - {0xD440, 0xD440, prLV}, // Lo HANGUL SYLLABLE POE - {0xD441, 0xD45B, prLVT}, // Lo [27] HANGUL SYLLABLE POEG..HANGUL SYLLABLE POEH - {0xD45C, 0xD45C, prLV}, // Lo HANGUL SYLLABLE PYO - {0xD45D, 0xD477, prLVT}, // Lo [27] HANGUL SYLLABLE PYOG..HANGUL SYLLABLE PYOH - {0xD478, 0xD478, prLV}, // Lo HANGUL SYLLABLE PU - {0xD479, 0xD493, prLVT}, // Lo [27] HANGUL SYLLABLE PUG..HANGUL SYLLABLE PUH - {0xD494, 0xD494, prLV}, // Lo HANGUL SYLLABLE PWEO - {0xD495, 0xD4AF, prLVT}, // Lo [27] HANGUL SYLLABLE PWEOG..HANGUL SYLLABLE PWEOH - {0xD4B0, 0xD4B0, prLV}, // Lo HANGUL SYLLABLE PWE - {0xD4B1, 0xD4CB, prLVT}, // Lo [27] HANGUL SYLLABLE PWEG..HANGUL SYLLABLE PWEH - {0xD4CC, 0xD4CC, prLV}, // Lo HANGUL SYLLABLE PWI - {0xD4CD, 0xD4E7, prLVT}, // Lo [27] HANGUL SYLLABLE PWIG..HANGUL SYLLABLE PWIH - {0xD4E8, 0xD4E8, prLV}, // Lo HANGUL SYLLABLE PYU - {0xD4E9, 0xD503, prLVT}, // Lo [27] HANGUL SYLLABLE PYUG..HANGUL SYLLABLE PYUH - {0xD504, 0xD504, prLV}, // Lo HANGUL SYLLABLE PEU - {0xD505, 0xD51F, prLVT}, // Lo [27] HANGUL SYLLABLE PEUG..HANGUL SYLLABLE PEUH - {0xD520, 0xD520, prLV}, // Lo HANGUL SYLLABLE PYI - {0xD521, 0xD53B, prLVT}, // Lo [27] HANGUL SYLLABLE PYIG..HANGUL SYLLABLE PYIH - {0xD53C, 0xD53C, prLV}, // Lo HANGUL SYLLABLE PI - {0xD53D, 0xD557, prLVT}, // Lo [27] HANGUL SYLLABLE PIG..HANGUL SYLLABLE PIH - {0xD558, 0xD558, prLV}, // Lo HANGUL SYLLABLE HA - {0xD559, 0xD573, prLVT}, // Lo [27] HANGUL SYLLABLE HAG..HANGUL SYLLABLE HAH - {0xD574, 0xD574, prLV}, // Lo HANGUL SYLLABLE HAE - {0xD575, 0xD58F, prLVT}, // Lo [27] HANGUL SYLLABLE HAEG..HANGUL SYLLABLE HAEH - {0xD590, 0xD590, prLV}, // Lo HANGUL SYLLABLE HYA - {0xD591, 0xD5AB, prLVT}, // Lo [27] HANGUL SYLLABLE HYAG..HANGUL SYLLABLE HYAH - {0xD5AC, 0xD5AC, prLV}, // Lo HANGUL SYLLABLE HYAE - {0xD5AD, 0xD5C7, prLVT}, // Lo [27] HANGUL SYLLABLE HYAEG..HANGUL SYLLABLE HYAEH - {0xD5C8, 0xD5C8, prLV}, // Lo HANGUL SYLLABLE HEO - {0xD5C9, 0xD5E3, prLVT}, // Lo [27] HANGUL SYLLABLE HEOG..HANGUL SYLLABLE HEOH - {0xD5E4, 0xD5E4, prLV}, // Lo HANGUL SYLLABLE HE - {0xD5E5, 0xD5FF, prLVT}, // Lo [27] HANGUL SYLLABLE HEG..HANGUL SYLLABLE HEH - {0xD600, 0xD600, prLV}, // Lo HANGUL SYLLABLE HYEO - {0xD601, 0xD61B, prLVT}, // Lo [27] HANGUL SYLLABLE HYEOG..HANGUL SYLLABLE HYEOH - {0xD61C, 0xD61C, prLV}, // Lo HANGUL SYLLABLE HYE - {0xD61D, 0xD637, prLVT}, // Lo [27] HANGUL SYLLABLE HYEG..HANGUL SYLLABLE HYEH - {0xD638, 0xD638, prLV}, // Lo HANGUL SYLLABLE HO - {0xD639, 0xD653, prLVT}, // Lo [27] HANGUL SYLLABLE HOG..HANGUL SYLLABLE HOH - {0xD654, 0xD654, prLV}, // Lo HANGUL SYLLABLE HWA - {0xD655, 0xD66F, prLVT}, // Lo [27] HANGUL SYLLABLE HWAG..HANGUL SYLLABLE HWAH - {0xD670, 0xD670, prLV}, // Lo HANGUL SYLLABLE HWAE - {0xD671, 0xD68B, prLVT}, // Lo [27] HANGUL SYLLABLE HWAEG..HANGUL SYLLABLE HWAEH - {0xD68C, 0xD68C, prLV}, // Lo HANGUL SYLLABLE HOE - {0xD68D, 0xD6A7, prLVT}, // Lo [27] HANGUL SYLLABLE HOEG..HANGUL SYLLABLE HOEH - {0xD6A8, 0xD6A8, prLV}, // Lo HANGUL SYLLABLE HYO - {0xD6A9, 0xD6C3, prLVT}, // Lo [27] HANGUL SYLLABLE HYOG..HANGUL SYLLABLE HYOH - {0xD6C4, 0xD6C4, prLV}, // Lo HANGUL SYLLABLE HU - {0xD6C5, 0xD6DF, prLVT}, // Lo [27] HANGUL SYLLABLE HUG..HANGUL SYLLABLE HUH - {0xD6E0, 0xD6E0, prLV}, // Lo HANGUL SYLLABLE HWEO - {0xD6E1, 0xD6FB, prLVT}, // Lo [27] HANGUL SYLLABLE HWEOG..HANGUL SYLLABLE HWEOH - {0xD6FC, 0xD6FC, prLV}, // Lo HANGUL SYLLABLE HWE - {0xD6FD, 0xD717, prLVT}, // Lo [27] HANGUL SYLLABLE HWEG..HANGUL SYLLABLE HWEH - {0xD718, 0xD718, prLV}, // Lo HANGUL SYLLABLE HWI - {0xD719, 0xD733, prLVT}, // Lo [27] HANGUL SYLLABLE HWIG..HANGUL SYLLABLE HWIH - {0xD734, 0xD734, prLV}, // Lo HANGUL SYLLABLE HYU - {0xD735, 0xD74F, prLVT}, // Lo [27] HANGUL SYLLABLE HYUG..HANGUL SYLLABLE HYUH - {0xD750, 0xD750, prLV}, // Lo HANGUL SYLLABLE HEU - {0xD751, 0xD76B, prLVT}, // Lo [27] HANGUL SYLLABLE HEUG..HANGUL SYLLABLE HEUH - {0xD76C, 0xD76C, prLV}, // Lo HANGUL SYLLABLE HYI - {0xD76D, 0xD787, prLVT}, // Lo [27] HANGUL SYLLABLE HYIG..HANGUL SYLLABLE HYIH - {0xD788, 0xD788, prLV}, // Lo HANGUL SYLLABLE HI - {0xD789, 0xD7A3, prLVT}, // Lo [27] HANGUL SYLLABLE HIG..HANGUL SYLLABLE HIH - {0xD7B0, 0xD7C6, prV}, // Lo [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E - {0xD7CB, 0xD7FB, prT}, // Lo [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH - {0xFB1E, 0xFB1E, prExtend}, // Mn HEBREW POINT JUDEO-SPANISH VARIKA - {0xFE00, 0xFE0F, prExtend}, // Mn [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16 - {0xFE20, 0xFE2F, prExtend}, // Mn [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF - {0xFEFF, 0xFEFF, prControl}, // Cf ZERO WIDTH NO-BREAK SPACE - {0xFF9E, 0xFF9F, prExtend}, // Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK - {0xFFF0, 0xFFF8, prControl}, // Cn [9] .. - {0xFFF9, 0xFFFB, prControl}, // Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR - {0x101FD, 0x101FD, prExtend}, // Mn PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE - {0x102E0, 0x102E0, prExtend}, // Mn COPTIC EPACT THOUSANDS MARK - {0x10376, 0x1037A, prExtend}, // Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII - {0x10A01, 0x10A03, prExtend}, // Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R - {0x10A05, 0x10A06, prExtend}, // Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O - {0x10A0C, 0x10A0F, prExtend}, // Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA - {0x10A38, 0x10A3A, prExtend}, // Mn [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW - {0x10A3F, 0x10A3F, prExtend}, // Mn KHAROSHTHI VIRAMA - {0x10AE5, 0x10AE6, prExtend}, // Mn [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW - {0x10D24, 0x10D27, prExtend}, // Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI - {0x10EAB, 0x10EAC, prExtend}, // Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK - {0x10EFD, 0x10EFF, prExtend}, // Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA - {0x10F46, 0x10F50, prExtend}, // Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW - {0x10F82, 0x10F85, prExtend}, // Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW - {0x11000, 0x11000, prSpacingMark}, // Mc BRAHMI SIGN CANDRABINDU - {0x11001, 0x11001, prExtend}, // Mn BRAHMI SIGN ANUSVARA - {0x11002, 0x11002, prSpacingMark}, // Mc BRAHMI SIGN VISARGA - {0x11038, 0x11046, prExtend}, // Mn [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA - {0x11070, 0x11070, prExtend}, // Mn BRAHMI SIGN OLD TAMIL VIRAMA - {0x11073, 0x11074, prExtend}, // Mn [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O - {0x1107F, 0x11081, prExtend}, // Mn [3] BRAHMI NUMBER JOINER..KAITHI SIGN ANUSVARA - {0x11082, 0x11082, prSpacingMark}, // Mc KAITHI SIGN VISARGA - {0x110B0, 0x110B2, prSpacingMark}, // Mc [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II - {0x110B3, 0x110B6, prExtend}, // Mn [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI - {0x110B7, 0x110B8, prSpacingMark}, // Mc [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU - {0x110B9, 0x110BA, prExtend}, // Mn [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA - {0x110BD, 0x110BD, prPrepend}, // Cf KAITHI NUMBER SIGN - {0x110C2, 0x110C2, prExtend}, // Mn KAITHI VOWEL SIGN VOCALIC R - {0x110CD, 0x110CD, prPrepend}, // Cf KAITHI NUMBER SIGN ABOVE - {0x11100, 0x11102, prExtend}, // Mn [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA - {0x11127, 0x1112B, prExtend}, // Mn [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU - {0x1112C, 0x1112C, prSpacingMark}, // Mc CHAKMA VOWEL SIGN E - {0x1112D, 0x11134, prExtend}, // Mn [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA - {0x11145, 0x11146, prSpacingMark}, // Mc [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI - {0x11173, 0x11173, prExtend}, // Mn MAHAJANI SIGN NUKTA - {0x11180, 0x11181, prExtend}, // Mn [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA - {0x11182, 0x11182, prSpacingMark}, // Mc SHARADA SIGN VISARGA - {0x111B3, 0x111B5, prSpacingMark}, // Mc [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II - {0x111B6, 0x111BE, prExtend}, // Mn [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O - {0x111BF, 0x111C0, prSpacingMark}, // Mc [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA - {0x111C2, 0x111C3, prPrepend}, // Lo [2] SHARADA SIGN JIHVAMULIYA..SHARADA SIGN UPADHMANIYA - {0x111C9, 0x111CC, prExtend}, // Mn [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK - {0x111CE, 0x111CE, prSpacingMark}, // Mc SHARADA VOWEL SIGN PRISHTHAMATRA E - {0x111CF, 0x111CF, prExtend}, // Mn SHARADA SIGN INVERTED CANDRABINDU - {0x1122C, 0x1122E, prSpacingMark}, // Mc [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II - {0x1122F, 0x11231, prExtend}, // Mn [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI - {0x11232, 0x11233, prSpacingMark}, // Mc [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU - {0x11234, 0x11234, prExtend}, // Mn KHOJKI SIGN ANUSVARA - {0x11235, 0x11235, prSpacingMark}, // Mc KHOJKI SIGN VIRAMA - {0x11236, 0x11237, prExtend}, // Mn [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA - {0x1123E, 0x1123E, prExtend}, // Mn KHOJKI SIGN SUKUN - {0x11241, 0x11241, prExtend}, // Mn KHOJKI VOWEL SIGN VOCALIC R - {0x112DF, 0x112DF, prExtend}, // Mn KHUDAWADI SIGN ANUSVARA - {0x112E0, 0x112E2, prSpacingMark}, // Mc [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II - {0x112E3, 0x112EA, prExtend}, // Mn [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA - {0x11300, 0x11301, prExtend}, // Mn [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU - {0x11302, 0x11303, prSpacingMark}, // Mc [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA - {0x1133B, 0x1133C, prExtend}, // Mn [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA - {0x1133E, 0x1133E, prExtend}, // Mc GRANTHA VOWEL SIGN AA - {0x1133F, 0x1133F, prSpacingMark}, // Mc GRANTHA VOWEL SIGN I - {0x11340, 0x11340, prExtend}, // Mn GRANTHA VOWEL SIGN II - {0x11341, 0x11344, prSpacingMark}, // Mc [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR - {0x11347, 0x11348, prSpacingMark}, // Mc [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI - {0x1134B, 0x1134D, prSpacingMark}, // Mc [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA - {0x11357, 0x11357, prExtend}, // Mc GRANTHA AU LENGTH MARK - {0x11362, 0x11363, prSpacingMark}, // Mc [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL - {0x11366, 0x1136C, prExtend}, // Mn [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX - {0x11370, 0x11374, prExtend}, // Mn [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA - {0x11435, 0x11437, prSpacingMark}, // Mc [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II - {0x11438, 0x1143F, prExtend}, // Mn [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI - {0x11440, 0x11441, prSpacingMark}, // Mc [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU - {0x11442, 0x11444, prExtend}, // Mn [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA - {0x11445, 0x11445, prSpacingMark}, // Mc NEWA SIGN VISARGA - {0x11446, 0x11446, prExtend}, // Mn NEWA SIGN NUKTA - {0x1145E, 0x1145E, prExtend}, // Mn NEWA SANDHI MARK - {0x114B0, 0x114B0, prExtend}, // Mc TIRHUTA VOWEL SIGN AA - {0x114B1, 0x114B2, prSpacingMark}, // Mc [2] TIRHUTA VOWEL SIGN I..TIRHUTA VOWEL SIGN II - {0x114B3, 0x114B8, prExtend}, // Mn [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL - {0x114B9, 0x114B9, prSpacingMark}, // Mc TIRHUTA VOWEL SIGN E - {0x114BA, 0x114BA, prExtend}, // Mn TIRHUTA VOWEL SIGN SHORT E - {0x114BB, 0x114BC, prSpacingMark}, // Mc [2] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN O - {0x114BD, 0x114BD, prExtend}, // Mc TIRHUTA VOWEL SIGN SHORT O - {0x114BE, 0x114BE, prSpacingMark}, // Mc TIRHUTA VOWEL SIGN AU - {0x114BF, 0x114C0, prExtend}, // Mn [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA - {0x114C1, 0x114C1, prSpacingMark}, // Mc TIRHUTA SIGN VISARGA - {0x114C2, 0x114C3, prExtend}, // Mn [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA - {0x115AF, 0x115AF, prExtend}, // Mc SIDDHAM VOWEL SIGN AA - {0x115B0, 0x115B1, prSpacingMark}, // Mc [2] SIDDHAM VOWEL SIGN I..SIDDHAM VOWEL SIGN II - {0x115B2, 0x115B5, prExtend}, // Mn [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR - {0x115B8, 0x115BB, prSpacingMark}, // Mc [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU - {0x115BC, 0x115BD, prExtend}, // Mn [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA - {0x115BE, 0x115BE, prSpacingMark}, // Mc SIDDHAM SIGN VISARGA - {0x115BF, 0x115C0, prExtend}, // Mn [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA - {0x115DC, 0x115DD, prExtend}, // Mn [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU - {0x11630, 0x11632, prSpacingMark}, // Mc [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II - {0x11633, 0x1163A, prExtend}, // Mn [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI - {0x1163B, 0x1163C, prSpacingMark}, // Mc [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU - {0x1163D, 0x1163D, prExtend}, // Mn MODI SIGN ANUSVARA - {0x1163E, 0x1163E, prSpacingMark}, // Mc MODI SIGN VISARGA - {0x1163F, 0x11640, prExtend}, // Mn [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA - {0x116AB, 0x116AB, prExtend}, // Mn TAKRI SIGN ANUSVARA - {0x116AC, 0x116AC, prSpacingMark}, // Mc TAKRI SIGN VISARGA - {0x116AD, 0x116AD, prExtend}, // Mn TAKRI VOWEL SIGN AA - {0x116AE, 0x116AF, prSpacingMark}, // Mc [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II - {0x116B0, 0x116B5, prExtend}, // Mn [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU - {0x116B6, 0x116B6, prSpacingMark}, // Mc TAKRI SIGN VIRAMA - {0x116B7, 0x116B7, prExtend}, // Mn TAKRI SIGN NUKTA - {0x1171D, 0x1171F, prExtend}, // Mn [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA - {0x11722, 0x11725, prExtend}, // Mn [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU - {0x11726, 0x11726, prSpacingMark}, // Mc AHOM VOWEL SIGN E - {0x11727, 0x1172B, prExtend}, // Mn [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER - {0x1182C, 0x1182E, prSpacingMark}, // Mc [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II - {0x1182F, 0x11837, prExtend}, // Mn [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA - {0x11838, 0x11838, prSpacingMark}, // Mc DOGRA SIGN VISARGA - {0x11839, 0x1183A, prExtend}, // Mn [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA - {0x11930, 0x11930, prExtend}, // Mc DIVES AKURU VOWEL SIGN AA - {0x11931, 0x11935, prSpacingMark}, // Mc [5] DIVES AKURU VOWEL SIGN I..DIVES AKURU VOWEL SIGN E - {0x11937, 0x11938, prSpacingMark}, // Mc [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O - {0x1193B, 0x1193C, prExtend}, // Mn [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU - {0x1193D, 0x1193D, prSpacingMark}, // Mc DIVES AKURU SIGN HALANTA - {0x1193E, 0x1193E, prExtend}, // Mn DIVES AKURU VIRAMA - {0x1193F, 0x1193F, prPrepend}, // Lo DIVES AKURU PREFIXED NASAL SIGN - {0x11940, 0x11940, prSpacingMark}, // Mc DIVES AKURU MEDIAL YA - {0x11941, 0x11941, prPrepend}, // Lo DIVES AKURU INITIAL RA - {0x11942, 0x11942, prSpacingMark}, // Mc DIVES AKURU MEDIAL RA - {0x11943, 0x11943, prExtend}, // Mn DIVES AKURU SIGN NUKTA - {0x119D1, 0x119D3, prSpacingMark}, // Mc [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II - {0x119D4, 0x119D7, prExtend}, // Mn [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR - {0x119DA, 0x119DB, prExtend}, // Mn [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI - {0x119DC, 0x119DF, prSpacingMark}, // Mc [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA - {0x119E0, 0x119E0, prExtend}, // Mn NANDINAGARI SIGN VIRAMA - {0x119E4, 0x119E4, prSpacingMark}, // Mc NANDINAGARI VOWEL SIGN PRISHTHAMATRA E - {0x11A01, 0x11A0A, prExtend}, // Mn [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK - {0x11A33, 0x11A38, prExtend}, // Mn [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA - {0x11A39, 0x11A39, prSpacingMark}, // Mc ZANABAZAR SQUARE SIGN VISARGA - {0x11A3A, 0x11A3A, prPrepend}, // Lo ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA - {0x11A3B, 0x11A3E, prExtend}, // Mn [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA - {0x11A47, 0x11A47, prExtend}, // Mn ZANABAZAR SQUARE SUBJOINER - {0x11A51, 0x11A56, prExtend}, // Mn [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE - {0x11A57, 0x11A58, prSpacingMark}, // Mc [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU - {0x11A59, 0x11A5B, prExtend}, // Mn [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK - {0x11A84, 0x11A89, prPrepend}, // Lo [6] SOYOMBO SIGN JIHVAMULIYA..SOYOMBO CLUSTER-INITIAL LETTER SA - {0x11A8A, 0x11A96, prExtend}, // Mn [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA - {0x11A97, 0x11A97, prSpacingMark}, // Mc SOYOMBO SIGN VISARGA - {0x11A98, 0x11A99, prExtend}, // Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER - {0x11C2F, 0x11C2F, prSpacingMark}, // Mc BHAIKSUKI VOWEL SIGN AA - {0x11C30, 0x11C36, prExtend}, // Mn [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L - {0x11C38, 0x11C3D, prExtend}, // Mn [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA - {0x11C3E, 0x11C3E, prSpacingMark}, // Mc BHAIKSUKI SIGN VISARGA - {0x11C3F, 0x11C3F, prExtend}, // Mn BHAIKSUKI SIGN VIRAMA - {0x11C92, 0x11CA7, prExtend}, // Mn [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA - {0x11CA9, 0x11CA9, prSpacingMark}, // Mc MARCHEN SUBJOINED LETTER YA - {0x11CAA, 0x11CB0, prExtend}, // Mn [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA - {0x11CB1, 0x11CB1, prSpacingMark}, // Mc MARCHEN VOWEL SIGN I - {0x11CB2, 0x11CB3, prExtend}, // Mn [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E - {0x11CB4, 0x11CB4, prSpacingMark}, // Mc MARCHEN VOWEL SIGN O - {0x11CB5, 0x11CB6, prExtend}, // Mn [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU - {0x11D31, 0x11D36, prExtend}, // Mn [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R - {0x11D3A, 0x11D3A, prExtend}, // Mn MASARAM GONDI VOWEL SIGN E - {0x11D3C, 0x11D3D, prExtend}, // Mn [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O - {0x11D3F, 0x11D45, prExtend}, // Mn [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA - {0x11D46, 0x11D46, prPrepend}, // Lo MASARAM GONDI REPHA - {0x11D47, 0x11D47, prExtend}, // Mn MASARAM GONDI RA-KARA - {0x11D8A, 0x11D8E, prSpacingMark}, // Mc [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU - {0x11D90, 0x11D91, prExtend}, // Mn [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI - {0x11D93, 0x11D94, prSpacingMark}, // Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU - {0x11D95, 0x11D95, prExtend}, // Mn GUNJALA GONDI SIGN ANUSVARA - {0x11D96, 0x11D96, prSpacingMark}, // Mc GUNJALA GONDI SIGN VISARGA - {0x11D97, 0x11D97, prExtend}, // Mn GUNJALA GONDI VIRAMA - {0x11EF3, 0x11EF4, prExtend}, // Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U - {0x11EF5, 0x11EF6, prSpacingMark}, // Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O - {0x11F00, 0x11F01, prExtend}, // Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA - {0x11F02, 0x11F02, prPrepend}, // Lo KAWI SIGN REPHA - {0x11F03, 0x11F03, prSpacingMark}, // Mc KAWI SIGN VISARGA - {0x11F34, 0x11F35, prSpacingMark}, // Mc [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA - {0x11F36, 0x11F3A, prExtend}, // Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R - {0x11F3E, 0x11F3F, prSpacingMark}, // Mc [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI - {0x11F40, 0x11F40, prExtend}, // Mn KAWI VOWEL SIGN EU - {0x11F41, 0x11F41, prSpacingMark}, // Mc KAWI SIGN KILLER - {0x11F42, 0x11F42, prExtend}, // Mn KAWI CONJOINER - {0x13430, 0x1343F, prControl}, // Cf [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE - {0x13440, 0x13440, prExtend}, // Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY - {0x13447, 0x13455, prExtend}, // Mn [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED - {0x16AF0, 0x16AF4, prExtend}, // Mn [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE - {0x16B30, 0x16B36, prExtend}, // Mn [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM - {0x16F4F, 0x16F4F, prExtend}, // Mn MIAO SIGN CONSONANT MODIFIER BAR - {0x16F51, 0x16F87, prSpacingMark}, // Mc [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI - {0x16F8F, 0x16F92, prExtend}, // Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW - {0x16FE4, 0x16FE4, prExtend}, // Mn KHITAN SMALL SCRIPT FILLER - {0x16FF0, 0x16FF1, prSpacingMark}, // Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY - {0x1BC9D, 0x1BC9E, prExtend}, // Mn [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK - {0x1BCA0, 0x1BCA3, prControl}, // Cf [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP - {0x1CF00, 0x1CF2D, prExtend}, // Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT - {0x1CF30, 0x1CF46, prExtend}, // Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG - {0x1D165, 0x1D165, prExtend}, // Mc MUSICAL SYMBOL COMBINING STEM - {0x1D166, 0x1D166, prSpacingMark}, // Mc MUSICAL SYMBOL COMBINING SPRECHGESANG STEM - {0x1D167, 0x1D169, prExtend}, // Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 - {0x1D16D, 0x1D16D, prSpacingMark}, // Mc MUSICAL SYMBOL COMBINING AUGMENTATION DOT - {0x1D16E, 0x1D172, prExtend}, // Mc [5] MUSICAL SYMBOL COMBINING FLAG-1..MUSICAL SYMBOL COMBINING FLAG-5 - {0x1D173, 0x1D17A, prControl}, // Cf [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE - {0x1D17B, 0x1D182, prExtend}, // Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE - {0x1D185, 0x1D18B, prExtend}, // Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE - {0x1D1AA, 0x1D1AD, prExtend}, // Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO - {0x1D242, 0x1D244, prExtend}, // Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME - {0x1DA00, 0x1DA36, prExtend}, // Mn [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN - {0x1DA3B, 0x1DA6C, prExtend}, // Mn [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT - {0x1DA75, 0x1DA75, prExtend}, // Mn SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS - {0x1DA84, 0x1DA84, prExtend}, // Mn SIGNWRITING LOCATION HEAD NECK - {0x1DA9B, 0x1DA9F, prExtend}, // Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 - {0x1DAA1, 0x1DAAF, prExtend}, // Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 - {0x1E000, 0x1E006, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE - {0x1E008, 0x1E018, prExtend}, // Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU - {0x1E01B, 0x1E021, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI - {0x1E023, 0x1E024, prExtend}, // Mn [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS - {0x1E026, 0x1E02A, prExtend}, // Mn [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA - {0x1E08F, 0x1E08F, prExtend}, // Mn COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I - {0x1E130, 0x1E136, prExtend}, // Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D - {0x1E2AE, 0x1E2AE, prExtend}, // Mn TOTO SIGN RISING TONE - {0x1E2EC, 0x1E2EF, prExtend}, // Mn [4] WANCHO TONE TUP..WANCHO TONE KOINI - {0x1E4EC, 0x1E4EF, prExtend}, // Mn [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH - {0x1E8D0, 0x1E8D6, prExtend}, // Mn [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS - {0x1E944, 0x1E94A, prExtend}, // Mn [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA - {0x1F000, 0x1F003, prExtendedPictographic}, // E0.0 [4] (🀀..🀃) MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND - {0x1F004, 0x1F004, prExtendedPictographic}, // E0.6 [1] (🀄) mahjong red dragon - {0x1F005, 0x1F0CE, prExtendedPictographic}, // E0.0 [202] (🀅..🃎) MAHJONG TILE GREEN DRAGON..PLAYING CARD KING OF DIAMONDS - {0x1F0CF, 0x1F0CF, prExtendedPictographic}, // E0.6 [1] (🃏) joker - {0x1F0D0, 0x1F0FF, prExtendedPictographic}, // E0.0 [48] (🃐..🃿) .. - {0x1F10D, 0x1F10F, prExtendedPictographic}, // E0.0 [3] (🄍..🄏) CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH - {0x1F12F, 0x1F12F, prExtendedPictographic}, // E0.0 [1] (🄯) COPYLEFT SYMBOL - {0x1F16C, 0x1F16F, prExtendedPictographic}, // E0.0 [4] (🅬..🅯) RAISED MR SIGN..CIRCLED HUMAN FIGURE - {0x1F170, 0x1F171, prExtendedPictographic}, // E0.6 [2] (🅰️..🅱️) A button (blood type)..B button (blood type) - {0x1F17E, 0x1F17F, prExtendedPictographic}, // E0.6 [2] (🅾️..🅿️) O button (blood type)..P button - {0x1F18E, 0x1F18E, prExtendedPictographic}, // E0.6 [1] (🆎) AB button (blood type) - {0x1F191, 0x1F19A, prExtendedPictographic}, // E0.6 [10] (🆑..🆚) CL button..VS button - {0x1F1AD, 0x1F1E5, prExtendedPictographic}, // E0.0 [57] (🆭..🇥) MASK WORK SYMBOL.. - {0x1F1E6, 0x1F1FF, prRegionalIndicator}, // So [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z - {0x1F201, 0x1F202, prExtendedPictographic}, // E0.6 [2] (🈁..🈂️) Japanese “here” button..Japanese “service charge” button - {0x1F203, 0x1F20F, prExtendedPictographic}, // E0.0 [13] (🈃..🈏) .. - {0x1F21A, 0x1F21A, prExtendedPictographic}, // E0.6 [1] (🈚) Japanese “free of charge” button - {0x1F22F, 0x1F22F, prExtendedPictographic}, // E0.6 [1] (🈯) Japanese “reserved” button - {0x1F232, 0x1F23A, prExtendedPictographic}, // E0.6 [9] (🈲..🈺) Japanese “prohibited” button..Japanese “open for business” button - {0x1F23C, 0x1F23F, prExtendedPictographic}, // E0.0 [4] (🈼..🈿) .. - {0x1F249, 0x1F24F, prExtendedPictographic}, // E0.0 [7] (🉉..🉏) .. - {0x1F250, 0x1F251, prExtendedPictographic}, // E0.6 [2] (🉐..🉑) Japanese “bargain” button..Japanese “acceptable” button - {0x1F252, 0x1F2FF, prExtendedPictographic}, // E0.0 [174] (🉒..🋿) .. - {0x1F300, 0x1F30C, prExtendedPictographic}, // E0.6 [13] (🌀..🌌) cyclone..milky way - {0x1F30D, 0x1F30E, prExtendedPictographic}, // E0.7 [2] (🌍..🌎) globe showing Europe-Africa..globe showing Americas - {0x1F30F, 0x1F30F, prExtendedPictographic}, // E0.6 [1] (🌏) globe showing Asia-Australia - {0x1F310, 0x1F310, prExtendedPictographic}, // E1.0 [1] (🌐) globe with meridians - {0x1F311, 0x1F311, prExtendedPictographic}, // E0.6 [1] (🌑) new moon - {0x1F312, 0x1F312, prExtendedPictographic}, // E1.0 [1] (🌒) waxing crescent moon - {0x1F313, 0x1F315, prExtendedPictographic}, // E0.6 [3] (🌓..🌕) first quarter moon..full moon - {0x1F316, 0x1F318, prExtendedPictographic}, // E1.0 [3] (🌖..🌘) waning gibbous moon..waning crescent moon - {0x1F319, 0x1F319, prExtendedPictographic}, // E0.6 [1] (🌙) crescent moon - {0x1F31A, 0x1F31A, prExtendedPictographic}, // E1.0 [1] (🌚) new moon face - {0x1F31B, 0x1F31B, prExtendedPictographic}, // E0.6 [1] (🌛) first quarter moon face - {0x1F31C, 0x1F31C, prExtendedPictographic}, // E0.7 [1] (🌜) last quarter moon face - {0x1F31D, 0x1F31E, prExtendedPictographic}, // E1.0 [2] (🌝..🌞) full moon face..sun with face - {0x1F31F, 0x1F320, prExtendedPictographic}, // E0.6 [2] (🌟..🌠) glowing star..shooting star - {0x1F321, 0x1F321, prExtendedPictographic}, // E0.7 [1] (🌡️) thermometer - {0x1F322, 0x1F323, prExtendedPictographic}, // E0.0 [2] (🌢..🌣) BLACK DROPLET..WHITE SUN - {0x1F324, 0x1F32C, prExtendedPictographic}, // E0.7 [9] (🌤️..🌬️) sun behind small cloud..wind face - {0x1F32D, 0x1F32F, prExtendedPictographic}, // E1.0 [3] (🌭..🌯) hot dog..burrito - {0x1F330, 0x1F331, prExtendedPictographic}, // E0.6 [2] (🌰..🌱) chestnut..seedling - {0x1F332, 0x1F333, prExtendedPictographic}, // E1.0 [2] (🌲..🌳) evergreen tree..deciduous tree - {0x1F334, 0x1F335, prExtendedPictographic}, // E0.6 [2] (🌴..🌵) palm tree..cactus - {0x1F336, 0x1F336, prExtendedPictographic}, // E0.7 [1] (🌶️) hot pepper - {0x1F337, 0x1F34A, prExtendedPictographic}, // E0.6 [20] (🌷..🍊) tulip..tangerine - {0x1F34B, 0x1F34B, prExtendedPictographic}, // E1.0 [1] (🍋) lemon - {0x1F34C, 0x1F34F, prExtendedPictographic}, // E0.6 [4] (🍌..🍏) banana..green apple - {0x1F350, 0x1F350, prExtendedPictographic}, // E1.0 [1] (🍐) pear - {0x1F351, 0x1F37B, prExtendedPictographic}, // E0.6 [43] (🍑..🍻) peach..clinking beer mugs - {0x1F37C, 0x1F37C, prExtendedPictographic}, // E1.0 [1] (🍼) baby bottle - {0x1F37D, 0x1F37D, prExtendedPictographic}, // E0.7 [1] (🍽️) fork and knife with plate - {0x1F37E, 0x1F37F, prExtendedPictographic}, // E1.0 [2] (🍾..🍿) bottle with popping cork..popcorn - {0x1F380, 0x1F393, prExtendedPictographic}, // E0.6 [20] (🎀..🎓) ribbon..graduation cap - {0x1F394, 0x1F395, prExtendedPictographic}, // E0.0 [2] (🎔..🎕) HEART WITH TIP ON THE LEFT..BOUQUET OF FLOWERS - {0x1F396, 0x1F397, prExtendedPictographic}, // E0.7 [2] (🎖️..🎗️) military medal..reminder ribbon - {0x1F398, 0x1F398, prExtendedPictographic}, // E0.0 [1] (🎘) MUSICAL KEYBOARD WITH JACKS - {0x1F399, 0x1F39B, prExtendedPictographic}, // E0.7 [3] (🎙️..🎛️) studio microphone..control knobs - {0x1F39C, 0x1F39D, prExtendedPictographic}, // E0.0 [2] (🎜..🎝) BEAMED ASCENDING MUSICAL NOTES..BEAMED DESCENDING MUSICAL NOTES - {0x1F39E, 0x1F39F, prExtendedPictographic}, // E0.7 [2] (🎞️..🎟️) film frames..admission tickets - {0x1F3A0, 0x1F3C4, prExtendedPictographic}, // E0.6 [37] (🎠..🏄) carousel horse..person surfing - {0x1F3C5, 0x1F3C5, prExtendedPictographic}, // E1.0 [1] (🏅) sports medal - {0x1F3C6, 0x1F3C6, prExtendedPictographic}, // E0.6 [1] (🏆) trophy - {0x1F3C7, 0x1F3C7, prExtendedPictographic}, // E1.0 [1] (🏇) horse racing - {0x1F3C8, 0x1F3C8, prExtendedPictographic}, // E0.6 [1] (🏈) american football - {0x1F3C9, 0x1F3C9, prExtendedPictographic}, // E1.0 [1] (🏉) rugby football - {0x1F3CA, 0x1F3CA, prExtendedPictographic}, // E0.6 [1] (🏊) person swimming - {0x1F3CB, 0x1F3CE, prExtendedPictographic}, // E0.7 [4] (🏋️..🏎️) person lifting weights..racing car - {0x1F3CF, 0x1F3D3, prExtendedPictographic}, // E1.0 [5] (🏏..🏓) cricket game..ping pong - {0x1F3D4, 0x1F3DF, prExtendedPictographic}, // E0.7 [12] (🏔️..🏟️) snow-capped mountain..stadium - {0x1F3E0, 0x1F3E3, prExtendedPictographic}, // E0.6 [4] (🏠..🏣) house..Japanese post office - {0x1F3E4, 0x1F3E4, prExtendedPictographic}, // E1.0 [1] (🏤) post office - {0x1F3E5, 0x1F3F0, prExtendedPictographic}, // E0.6 [12] (🏥..🏰) hospital..castle - {0x1F3F1, 0x1F3F2, prExtendedPictographic}, // E0.0 [2] (🏱..🏲) WHITE PENNANT..BLACK PENNANT - {0x1F3F3, 0x1F3F3, prExtendedPictographic}, // E0.7 [1] (🏳️) white flag - {0x1F3F4, 0x1F3F4, prExtendedPictographic}, // E1.0 [1] (🏴) black flag - {0x1F3F5, 0x1F3F5, prExtendedPictographic}, // E0.7 [1] (🏵️) rosette - {0x1F3F6, 0x1F3F6, prExtendedPictographic}, // E0.0 [1] (🏶) BLACK ROSETTE - {0x1F3F7, 0x1F3F7, prExtendedPictographic}, // E0.7 [1] (🏷️) label - {0x1F3F8, 0x1F3FA, prExtendedPictographic}, // E1.0 [3] (🏸..🏺) badminton..amphora - {0x1F3FB, 0x1F3FF, prExtend}, // Sk [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6 - {0x1F400, 0x1F407, prExtendedPictographic}, // E1.0 [8] (🐀..🐇) rat..rabbit - {0x1F408, 0x1F408, prExtendedPictographic}, // E0.7 [1] (🐈) cat - {0x1F409, 0x1F40B, prExtendedPictographic}, // E1.0 [3] (🐉..🐋) dragon..whale - {0x1F40C, 0x1F40E, prExtendedPictographic}, // E0.6 [3] (🐌..🐎) snail..horse - {0x1F40F, 0x1F410, prExtendedPictographic}, // E1.0 [2] (🐏..🐐) ram..goat - {0x1F411, 0x1F412, prExtendedPictographic}, // E0.6 [2] (🐑..🐒) ewe..monkey - {0x1F413, 0x1F413, prExtendedPictographic}, // E1.0 [1] (🐓) rooster - {0x1F414, 0x1F414, prExtendedPictographic}, // E0.6 [1] (🐔) chicken - {0x1F415, 0x1F415, prExtendedPictographic}, // E0.7 [1] (🐕) dog - {0x1F416, 0x1F416, prExtendedPictographic}, // E1.0 [1] (🐖) pig - {0x1F417, 0x1F429, prExtendedPictographic}, // E0.6 [19] (🐗..🐩) boar..poodle - {0x1F42A, 0x1F42A, prExtendedPictographic}, // E1.0 [1] (🐪) camel - {0x1F42B, 0x1F43E, prExtendedPictographic}, // E0.6 [20] (🐫..🐾) two-hump camel..paw prints - {0x1F43F, 0x1F43F, prExtendedPictographic}, // E0.7 [1] (🐿️) chipmunk - {0x1F440, 0x1F440, prExtendedPictographic}, // E0.6 [1] (👀) eyes - {0x1F441, 0x1F441, prExtendedPictographic}, // E0.7 [1] (👁️) eye - {0x1F442, 0x1F464, prExtendedPictographic}, // E0.6 [35] (👂..👤) ear..bust in silhouette - {0x1F465, 0x1F465, prExtendedPictographic}, // E1.0 [1] (👥) busts in silhouette - {0x1F466, 0x1F46B, prExtendedPictographic}, // E0.6 [6] (👦..👫) boy..woman and man holding hands - {0x1F46C, 0x1F46D, prExtendedPictographic}, // E1.0 [2] (👬..👭) men holding hands..women holding hands - {0x1F46E, 0x1F4AC, prExtendedPictographic}, // E0.6 [63] (👮..💬) police officer..speech balloon - {0x1F4AD, 0x1F4AD, prExtendedPictographic}, // E1.0 [1] (💭) thought balloon - {0x1F4AE, 0x1F4B5, prExtendedPictographic}, // E0.6 [8] (💮..💵) white flower..dollar banknote - {0x1F4B6, 0x1F4B7, prExtendedPictographic}, // E1.0 [2] (💶..💷) euro banknote..pound banknote - {0x1F4B8, 0x1F4EB, prExtendedPictographic}, // E0.6 [52] (💸..📫) money with wings..closed mailbox with raised flag - {0x1F4EC, 0x1F4ED, prExtendedPictographic}, // E0.7 [2] (📬..📭) open mailbox with raised flag..open mailbox with lowered flag - {0x1F4EE, 0x1F4EE, prExtendedPictographic}, // E0.6 [1] (📮) postbox - {0x1F4EF, 0x1F4EF, prExtendedPictographic}, // E1.0 [1] (📯) postal horn - {0x1F4F0, 0x1F4F4, prExtendedPictographic}, // E0.6 [5] (📰..📴) newspaper..mobile phone off - {0x1F4F5, 0x1F4F5, prExtendedPictographic}, // E1.0 [1] (📵) no mobile phones - {0x1F4F6, 0x1F4F7, prExtendedPictographic}, // E0.6 [2] (📶..📷) antenna bars..camera - {0x1F4F8, 0x1F4F8, prExtendedPictographic}, // E1.0 [1] (📸) camera with flash - {0x1F4F9, 0x1F4FC, prExtendedPictographic}, // E0.6 [4] (📹..📼) video camera..videocassette - {0x1F4FD, 0x1F4FD, prExtendedPictographic}, // E0.7 [1] (📽️) film projector - {0x1F4FE, 0x1F4FE, prExtendedPictographic}, // E0.0 [1] (📾) PORTABLE STEREO - {0x1F4FF, 0x1F502, prExtendedPictographic}, // E1.0 [4] (📿..🔂) prayer beads..repeat single button - {0x1F503, 0x1F503, prExtendedPictographic}, // E0.6 [1] (🔃) clockwise vertical arrows - {0x1F504, 0x1F507, prExtendedPictographic}, // E1.0 [4] (🔄..🔇) counterclockwise arrows button..muted speaker - {0x1F508, 0x1F508, prExtendedPictographic}, // E0.7 [1] (🔈) speaker low volume - {0x1F509, 0x1F509, prExtendedPictographic}, // E1.0 [1] (🔉) speaker medium volume - {0x1F50A, 0x1F514, prExtendedPictographic}, // E0.6 [11] (🔊..🔔) speaker high volume..bell - {0x1F515, 0x1F515, prExtendedPictographic}, // E1.0 [1] (🔕) bell with slash - {0x1F516, 0x1F52B, prExtendedPictographic}, // E0.6 [22] (🔖..🔫) bookmark..water pistol - {0x1F52C, 0x1F52D, prExtendedPictographic}, // E1.0 [2] (🔬..🔭) microscope..telescope - {0x1F52E, 0x1F53D, prExtendedPictographic}, // E0.6 [16] (🔮..🔽) crystal ball..downwards button - {0x1F546, 0x1F548, prExtendedPictographic}, // E0.0 [3] (🕆..🕈) WHITE LATIN CROSS..CELTIC CROSS - {0x1F549, 0x1F54A, prExtendedPictographic}, // E0.7 [2] (🕉️..🕊️) om..dove - {0x1F54B, 0x1F54E, prExtendedPictographic}, // E1.0 [4] (🕋..🕎) kaaba..menorah - {0x1F54F, 0x1F54F, prExtendedPictographic}, // E0.0 [1] (🕏) BOWL OF HYGIEIA - {0x1F550, 0x1F55B, prExtendedPictographic}, // E0.6 [12] (🕐..🕛) one o’clock..twelve o’clock - {0x1F55C, 0x1F567, prExtendedPictographic}, // E0.7 [12] (🕜..🕧) one-thirty..twelve-thirty - {0x1F568, 0x1F56E, prExtendedPictographic}, // E0.0 [7] (🕨..🕮) RIGHT SPEAKER..BOOK - {0x1F56F, 0x1F570, prExtendedPictographic}, // E0.7 [2] (🕯️..🕰️) candle..mantelpiece clock - {0x1F571, 0x1F572, prExtendedPictographic}, // E0.0 [2] (🕱..🕲) BLACK SKULL AND CROSSBONES..NO PIRACY - {0x1F573, 0x1F579, prExtendedPictographic}, // E0.7 [7] (🕳️..🕹️) hole..joystick - {0x1F57A, 0x1F57A, prExtendedPictographic}, // E3.0 [1] (🕺) man dancing - {0x1F57B, 0x1F586, prExtendedPictographic}, // E0.0 [12] (🕻..🖆) LEFT HAND TELEPHONE RECEIVER..PEN OVER STAMPED ENVELOPE - {0x1F587, 0x1F587, prExtendedPictographic}, // E0.7 [1] (🖇️) linked paperclips - {0x1F588, 0x1F589, prExtendedPictographic}, // E0.0 [2] (🖈..🖉) BLACK PUSHPIN..LOWER LEFT PENCIL - {0x1F58A, 0x1F58D, prExtendedPictographic}, // E0.7 [4] (🖊️..🖍️) pen..crayon - {0x1F58E, 0x1F58F, prExtendedPictographic}, // E0.0 [2] (🖎..🖏) LEFT WRITING HAND..TURNED OK HAND SIGN - {0x1F590, 0x1F590, prExtendedPictographic}, // E0.7 [1] (🖐️) hand with fingers splayed - {0x1F591, 0x1F594, prExtendedPictographic}, // E0.0 [4] (🖑..🖔) REVERSED RAISED HAND WITH FINGERS SPLAYED..REVERSED VICTORY HAND - {0x1F595, 0x1F596, prExtendedPictographic}, // E1.0 [2] (🖕..🖖) middle finger..vulcan salute - {0x1F597, 0x1F5A3, prExtendedPictographic}, // E0.0 [13] (🖗..🖣) WHITE DOWN POINTING LEFT HAND INDEX..BLACK DOWN POINTING BACKHAND INDEX - {0x1F5A4, 0x1F5A4, prExtendedPictographic}, // E3.0 [1] (🖤) black heart - {0x1F5A5, 0x1F5A5, prExtendedPictographic}, // E0.7 [1] (🖥️) desktop computer - {0x1F5A6, 0x1F5A7, prExtendedPictographic}, // E0.0 [2] (🖦..🖧) KEYBOARD AND MOUSE..THREE NETWORKED COMPUTERS - {0x1F5A8, 0x1F5A8, prExtendedPictographic}, // E0.7 [1] (🖨️) printer - {0x1F5A9, 0x1F5B0, prExtendedPictographic}, // E0.0 [8] (🖩..🖰) POCKET CALCULATOR..TWO BUTTON MOUSE - {0x1F5B1, 0x1F5B2, prExtendedPictographic}, // E0.7 [2] (🖱️..🖲️) computer mouse..trackball - {0x1F5B3, 0x1F5BB, prExtendedPictographic}, // E0.0 [9] (🖳..🖻) OLD PERSONAL COMPUTER..DOCUMENT WITH PICTURE - {0x1F5BC, 0x1F5BC, prExtendedPictographic}, // E0.7 [1] (🖼️) framed picture - {0x1F5BD, 0x1F5C1, prExtendedPictographic}, // E0.0 [5] (🖽..🗁) FRAME WITH TILES..OPEN FOLDER - {0x1F5C2, 0x1F5C4, prExtendedPictographic}, // E0.7 [3] (🗂️..🗄️) card index dividers..file cabinet - {0x1F5C5, 0x1F5D0, prExtendedPictographic}, // E0.0 [12] (🗅..🗐) EMPTY NOTE..PAGES - {0x1F5D1, 0x1F5D3, prExtendedPictographic}, // E0.7 [3] (🗑️..🗓️) wastebasket..spiral calendar - {0x1F5D4, 0x1F5DB, prExtendedPictographic}, // E0.0 [8] (🗔..🗛) DESKTOP WINDOW..DECREASE FONT SIZE SYMBOL - {0x1F5DC, 0x1F5DE, prExtendedPictographic}, // E0.7 [3] (🗜️..🗞️) clamp..rolled-up newspaper - {0x1F5DF, 0x1F5E0, prExtendedPictographic}, // E0.0 [2] (🗟..🗠) PAGE WITH CIRCLED TEXT..STOCK CHART - {0x1F5E1, 0x1F5E1, prExtendedPictographic}, // E0.7 [1] (🗡️) dagger - {0x1F5E2, 0x1F5E2, prExtendedPictographic}, // E0.0 [1] (🗢) LIPS - {0x1F5E3, 0x1F5E3, prExtendedPictographic}, // E0.7 [1] (🗣️) speaking head - {0x1F5E4, 0x1F5E7, prExtendedPictographic}, // E0.0 [4] (🗤..🗧) THREE RAYS ABOVE..THREE RAYS RIGHT - {0x1F5E8, 0x1F5E8, prExtendedPictographic}, // E2.0 [1] (🗨️) left speech bubble - {0x1F5E9, 0x1F5EE, prExtendedPictographic}, // E0.0 [6] (🗩..🗮) RIGHT SPEECH BUBBLE..LEFT ANGER BUBBLE - {0x1F5EF, 0x1F5EF, prExtendedPictographic}, // E0.7 [1] (🗯️) right anger bubble - {0x1F5F0, 0x1F5F2, prExtendedPictographic}, // E0.0 [3] (🗰..🗲) MOOD BUBBLE..LIGHTNING MOOD - {0x1F5F3, 0x1F5F3, prExtendedPictographic}, // E0.7 [1] (🗳️) ballot box with ballot - {0x1F5F4, 0x1F5F9, prExtendedPictographic}, // E0.0 [6] (🗴..🗹) BALLOT SCRIPT X..BALLOT BOX WITH BOLD CHECK - {0x1F5FA, 0x1F5FA, prExtendedPictographic}, // E0.7 [1] (🗺️) world map - {0x1F5FB, 0x1F5FF, prExtendedPictographic}, // E0.6 [5] (🗻..🗿) mount fuji..moai - {0x1F600, 0x1F600, prExtendedPictographic}, // E1.0 [1] (😀) grinning face - {0x1F601, 0x1F606, prExtendedPictographic}, // E0.6 [6] (😁..😆) beaming face with smiling eyes..grinning squinting face - {0x1F607, 0x1F608, prExtendedPictographic}, // E1.0 [2] (😇..😈) smiling face with halo..smiling face with horns - {0x1F609, 0x1F60D, prExtendedPictographic}, // E0.6 [5] (😉..😍) winking face..smiling face with heart-eyes - {0x1F60E, 0x1F60E, prExtendedPictographic}, // E1.0 [1] (😎) smiling face with sunglasses - {0x1F60F, 0x1F60F, prExtendedPictographic}, // E0.6 [1] (😏) smirking face - {0x1F610, 0x1F610, prExtendedPictographic}, // E0.7 [1] (😐) neutral face - {0x1F611, 0x1F611, prExtendedPictographic}, // E1.0 [1] (😑) expressionless face - {0x1F612, 0x1F614, prExtendedPictographic}, // E0.6 [3] (😒..😔) unamused face..pensive face - {0x1F615, 0x1F615, prExtendedPictographic}, // E1.0 [1] (😕) confused face - {0x1F616, 0x1F616, prExtendedPictographic}, // E0.6 [1] (😖) confounded face - {0x1F617, 0x1F617, prExtendedPictographic}, // E1.0 [1] (😗) kissing face - {0x1F618, 0x1F618, prExtendedPictographic}, // E0.6 [1] (😘) face blowing a kiss - {0x1F619, 0x1F619, prExtendedPictographic}, // E1.0 [1] (😙) kissing face with smiling eyes - {0x1F61A, 0x1F61A, prExtendedPictographic}, // E0.6 [1] (😚) kissing face with closed eyes - {0x1F61B, 0x1F61B, prExtendedPictographic}, // E1.0 [1] (😛) face with tongue - {0x1F61C, 0x1F61E, prExtendedPictographic}, // E0.6 [3] (😜..😞) winking face with tongue..disappointed face - {0x1F61F, 0x1F61F, prExtendedPictographic}, // E1.0 [1] (😟) worried face - {0x1F620, 0x1F625, prExtendedPictographic}, // E0.6 [6] (😠..😥) angry face..sad but relieved face - {0x1F626, 0x1F627, prExtendedPictographic}, // E1.0 [2] (😦..😧) frowning face with open mouth..anguished face - {0x1F628, 0x1F62B, prExtendedPictographic}, // E0.6 [4] (😨..😫) fearful face..tired face - {0x1F62C, 0x1F62C, prExtendedPictographic}, // E1.0 [1] (😬) grimacing face - {0x1F62D, 0x1F62D, prExtendedPictographic}, // E0.6 [1] (😭) loudly crying face - {0x1F62E, 0x1F62F, prExtendedPictographic}, // E1.0 [2] (😮..😯) face with open mouth..hushed face - {0x1F630, 0x1F633, prExtendedPictographic}, // E0.6 [4] (😰..😳) anxious face with sweat..flushed face - {0x1F634, 0x1F634, prExtendedPictographic}, // E1.0 [1] (😴) sleeping face - {0x1F635, 0x1F635, prExtendedPictographic}, // E0.6 [1] (😵) face with crossed-out eyes - {0x1F636, 0x1F636, prExtendedPictographic}, // E1.0 [1] (😶) face without mouth - {0x1F637, 0x1F640, prExtendedPictographic}, // E0.6 [10] (😷..🙀) face with medical mask..weary cat - {0x1F641, 0x1F644, prExtendedPictographic}, // E1.0 [4] (🙁..🙄) slightly frowning face..face with rolling eyes - {0x1F645, 0x1F64F, prExtendedPictographic}, // E0.6 [11] (🙅..🙏) person gesturing NO..folded hands - {0x1F680, 0x1F680, prExtendedPictographic}, // E0.6 [1] (🚀) rocket - {0x1F681, 0x1F682, prExtendedPictographic}, // E1.0 [2] (🚁..🚂) helicopter..locomotive - {0x1F683, 0x1F685, prExtendedPictographic}, // E0.6 [3] (🚃..🚅) railway car..bullet train - {0x1F686, 0x1F686, prExtendedPictographic}, // E1.0 [1] (🚆) train - {0x1F687, 0x1F687, prExtendedPictographic}, // E0.6 [1] (🚇) metro - {0x1F688, 0x1F688, prExtendedPictographic}, // E1.0 [1] (🚈) light rail - {0x1F689, 0x1F689, prExtendedPictographic}, // E0.6 [1] (🚉) station - {0x1F68A, 0x1F68B, prExtendedPictographic}, // E1.0 [2] (🚊..🚋) tram..tram car - {0x1F68C, 0x1F68C, prExtendedPictographic}, // E0.6 [1] (🚌) bus - {0x1F68D, 0x1F68D, prExtendedPictographic}, // E0.7 [1] (🚍) oncoming bus - {0x1F68E, 0x1F68E, prExtendedPictographic}, // E1.0 [1] (🚎) trolleybus - {0x1F68F, 0x1F68F, prExtendedPictographic}, // E0.6 [1] (🚏) bus stop - {0x1F690, 0x1F690, prExtendedPictographic}, // E1.0 [1] (🚐) minibus - {0x1F691, 0x1F693, prExtendedPictographic}, // E0.6 [3] (🚑..🚓) ambulance..police car - {0x1F694, 0x1F694, prExtendedPictographic}, // E0.7 [1] (🚔) oncoming police car - {0x1F695, 0x1F695, prExtendedPictographic}, // E0.6 [1] (🚕) taxi - {0x1F696, 0x1F696, prExtendedPictographic}, // E1.0 [1] (🚖) oncoming taxi - {0x1F697, 0x1F697, prExtendedPictographic}, // E0.6 [1] (🚗) automobile - {0x1F698, 0x1F698, prExtendedPictographic}, // E0.7 [1] (🚘) oncoming automobile - {0x1F699, 0x1F69A, prExtendedPictographic}, // E0.6 [2] (🚙..🚚) sport utility vehicle..delivery truck - {0x1F69B, 0x1F6A1, prExtendedPictographic}, // E1.0 [7] (🚛..🚡) articulated lorry..aerial tramway - {0x1F6A2, 0x1F6A2, prExtendedPictographic}, // E0.6 [1] (🚢) ship - {0x1F6A3, 0x1F6A3, prExtendedPictographic}, // E1.0 [1] (🚣) person rowing boat - {0x1F6A4, 0x1F6A5, prExtendedPictographic}, // E0.6 [2] (🚤..🚥) speedboat..horizontal traffic light - {0x1F6A6, 0x1F6A6, prExtendedPictographic}, // E1.0 [1] (🚦) vertical traffic light - {0x1F6A7, 0x1F6AD, prExtendedPictographic}, // E0.6 [7] (🚧..🚭) construction..no smoking - {0x1F6AE, 0x1F6B1, prExtendedPictographic}, // E1.0 [4] (🚮..🚱) litter in bin sign..non-potable water - {0x1F6B2, 0x1F6B2, prExtendedPictographic}, // E0.6 [1] (🚲) bicycle - {0x1F6B3, 0x1F6B5, prExtendedPictographic}, // E1.0 [3] (🚳..🚵) no bicycles..person mountain biking - {0x1F6B6, 0x1F6B6, prExtendedPictographic}, // E0.6 [1] (🚶) person walking - {0x1F6B7, 0x1F6B8, prExtendedPictographic}, // E1.0 [2] (🚷..🚸) no pedestrians..children crossing - {0x1F6B9, 0x1F6BE, prExtendedPictographic}, // E0.6 [6] (🚹..🚾) men’s room..water closet - {0x1F6BF, 0x1F6BF, prExtendedPictographic}, // E1.0 [1] (🚿) shower - {0x1F6C0, 0x1F6C0, prExtendedPictographic}, // E0.6 [1] (🛀) person taking bath - {0x1F6C1, 0x1F6C5, prExtendedPictographic}, // E1.0 [5] (🛁..🛅) bathtub..left luggage - {0x1F6C6, 0x1F6CA, prExtendedPictographic}, // E0.0 [5] (🛆..🛊) TRIANGLE WITH ROUNDED CORNERS..GIRLS SYMBOL - {0x1F6CB, 0x1F6CB, prExtendedPictographic}, // E0.7 [1] (🛋️) couch and lamp - {0x1F6CC, 0x1F6CC, prExtendedPictographic}, // E1.0 [1] (🛌) person in bed - {0x1F6CD, 0x1F6CF, prExtendedPictographic}, // E0.7 [3] (🛍️..🛏️) shopping bags..bed - {0x1F6D0, 0x1F6D0, prExtendedPictographic}, // E1.0 [1] (🛐) place of worship - {0x1F6D1, 0x1F6D2, prExtendedPictographic}, // E3.0 [2] (🛑..🛒) stop sign..shopping cart - {0x1F6D3, 0x1F6D4, prExtendedPictographic}, // E0.0 [2] (🛓..🛔) STUPA..PAGODA - {0x1F6D5, 0x1F6D5, prExtendedPictographic}, // E12.0 [1] (🛕) hindu temple - {0x1F6D6, 0x1F6D7, prExtendedPictographic}, // E13.0 [2] (🛖..🛗) hut..elevator - {0x1F6D8, 0x1F6DB, prExtendedPictographic}, // E0.0 [4] (🛘..🛛) .. - {0x1F6DC, 0x1F6DC, prExtendedPictographic}, // E15.0 [1] (🛜) wireless - {0x1F6DD, 0x1F6DF, prExtendedPictographic}, // E14.0 [3] (🛝..🛟) playground slide..ring buoy - {0x1F6E0, 0x1F6E5, prExtendedPictographic}, // E0.7 [6] (🛠️..🛥️) hammer and wrench..motor boat - {0x1F6E6, 0x1F6E8, prExtendedPictographic}, // E0.0 [3] (🛦..🛨) UP-POINTING MILITARY AIRPLANE..UP-POINTING SMALL AIRPLANE - {0x1F6E9, 0x1F6E9, prExtendedPictographic}, // E0.7 [1] (🛩️) small airplane - {0x1F6EA, 0x1F6EA, prExtendedPictographic}, // E0.0 [1] (🛪) NORTHEAST-POINTING AIRPLANE - {0x1F6EB, 0x1F6EC, prExtendedPictographic}, // E1.0 [2] (🛫..🛬) airplane departure..airplane arrival - {0x1F6ED, 0x1F6EF, prExtendedPictographic}, // E0.0 [3] (🛭..🛯) .. - {0x1F6F0, 0x1F6F0, prExtendedPictographic}, // E0.7 [1] (🛰️) satellite - {0x1F6F1, 0x1F6F2, prExtendedPictographic}, // E0.0 [2] (🛱..🛲) ONCOMING FIRE ENGINE..DIESEL LOCOMOTIVE - {0x1F6F3, 0x1F6F3, prExtendedPictographic}, // E0.7 [1] (🛳️) passenger ship - {0x1F6F4, 0x1F6F6, prExtendedPictographic}, // E3.0 [3] (🛴..🛶) kick scooter..canoe - {0x1F6F7, 0x1F6F8, prExtendedPictographic}, // E5.0 [2] (🛷..🛸) sled..flying saucer - {0x1F6F9, 0x1F6F9, prExtendedPictographic}, // E11.0 [1] (🛹) skateboard - {0x1F6FA, 0x1F6FA, prExtendedPictographic}, // E12.0 [1] (🛺) auto rickshaw - {0x1F6FB, 0x1F6FC, prExtendedPictographic}, // E13.0 [2] (🛻..🛼) pickup truck..roller skate - {0x1F6FD, 0x1F6FF, prExtendedPictographic}, // E0.0 [3] (🛽..🛿) .. - {0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0 [12] (🝴..🝿) LOT OF FORTUNE..ORCUS - {0x1F7D5, 0x1F7DF, prExtendedPictographic}, // E0.0 [11] (🟕..🟟) CIRCLED TRIANGLE.. - {0x1F7E0, 0x1F7EB, prExtendedPictographic}, // E12.0 [12] (🟠..🟫) orange circle..brown square - {0x1F7EC, 0x1F7EF, prExtendedPictographic}, // E0.0 [4] (🟬..🟯) .. - {0x1F7F0, 0x1F7F0, prExtendedPictographic}, // E14.0 [1] (🟰) heavy equals sign - {0x1F7F1, 0x1F7FF, prExtendedPictographic}, // E0.0 [15] (🟱..🟿) .. - {0x1F80C, 0x1F80F, prExtendedPictographic}, // E0.0 [4] (🠌..🠏) .. - {0x1F848, 0x1F84F, prExtendedPictographic}, // E0.0 [8] (🡈..🡏) .. - {0x1F85A, 0x1F85F, prExtendedPictographic}, // E0.0 [6] (🡚..🡟) .. - {0x1F888, 0x1F88F, prExtendedPictographic}, // E0.0 [8] (🢈..🢏) .. - {0x1F8AE, 0x1F8FF, prExtendedPictographic}, // E0.0 [82] (🢮..🣿) .. - {0x1F90C, 0x1F90C, prExtendedPictographic}, // E13.0 [1] (🤌) pinched fingers - {0x1F90D, 0x1F90F, prExtendedPictographic}, // E12.0 [3] (🤍..🤏) white heart..pinching hand - {0x1F910, 0x1F918, prExtendedPictographic}, // E1.0 [9] (🤐..🤘) zipper-mouth face..sign of the horns - {0x1F919, 0x1F91E, prExtendedPictographic}, // E3.0 [6] (🤙..🤞) call me hand..crossed fingers - {0x1F91F, 0x1F91F, prExtendedPictographic}, // E5.0 [1] (🤟) love-you gesture - {0x1F920, 0x1F927, prExtendedPictographic}, // E3.0 [8] (🤠..🤧) cowboy hat face..sneezing face - {0x1F928, 0x1F92F, prExtendedPictographic}, // E5.0 [8] (🤨..🤯) face with raised eyebrow..exploding head - {0x1F930, 0x1F930, prExtendedPictographic}, // E3.0 [1] (🤰) pregnant woman - {0x1F931, 0x1F932, prExtendedPictographic}, // E5.0 [2] (🤱..🤲) breast-feeding..palms up together - {0x1F933, 0x1F93A, prExtendedPictographic}, // E3.0 [8] (🤳..🤺) selfie..person fencing - {0x1F93C, 0x1F93E, prExtendedPictographic}, // E3.0 [3] (🤼..🤾) people wrestling..person playing handball - {0x1F93F, 0x1F93F, prExtendedPictographic}, // E12.0 [1] (🤿) diving mask - {0x1F940, 0x1F945, prExtendedPictographic}, // E3.0 [6] (🥀..🥅) wilted flower..goal net - {0x1F947, 0x1F94B, prExtendedPictographic}, // E3.0 [5] (🥇..🥋) 1st place medal..martial arts uniform - {0x1F94C, 0x1F94C, prExtendedPictographic}, // E5.0 [1] (🥌) curling stone - {0x1F94D, 0x1F94F, prExtendedPictographic}, // E11.0 [3] (🥍..🥏) lacrosse..flying disc - {0x1F950, 0x1F95E, prExtendedPictographic}, // E3.0 [15] (🥐..🥞) croissant..pancakes - {0x1F95F, 0x1F96B, prExtendedPictographic}, // E5.0 [13] (🥟..🥫) dumpling..canned food - {0x1F96C, 0x1F970, prExtendedPictographic}, // E11.0 [5] (🥬..🥰) leafy green..smiling face with hearts - {0x1F971, 0x1F971, prExtendedPictographic}, // E12.0 [1] (🥱) yawning face - {0x1F972, 0x1F972, prExtendedPictographic}, // E13.0 [1] (🥲) smiling face with tear - {0x1F973, 0x1F976, prExtendedPictographic}, // E11.0 [4] (🥳..🥶) partying face..cold face - {0x1F977, 0x1F978, prExtendedPictographic}, // E13.0 [2] (🥷..🥸) ninja..disguised face - {0x1F979, 0x1F979, prExtendedPictographic}, // E14.0 [1] (🥹) face holding back tears - {0x1F97A, 0x1F97A, prExtendedPictographic}, // E11.0 [1] (🥺) pleading face - {0x1F97B, 0x1F97B, prExtendedPictographic}, // E12.0 [1] (🥻) sari - {0x1F97C, 0x1F97F, prExtendedPictographic}, // E11.0 [4] (🥼..🥿) lab coat..flat shoe - {0x1F980, 0x1F984, prExtendedPictographic}, // E1.0 [5] (🦀..🦄) crab..unicorn - {0x1F985, 0x1F991, prExtendedPictographic}, // E3.0 [13] (🦅..🦑) eagle..squid - {0x1F992, 0x1F997, prExtendedPictographic}, // E5.0 [6] (🦒..🦗) giraffe..cricket - {0x1F998, 0x1F9A2, prExtendedPictographic}, // E11.0 [11] (🦘..🦢) kangaroo..swan - {0x1F9A3, 0x1F9A4, prExtendedPictographic}, // E13.0 [2] (🦣..🦤) mammoth..dodo - {0x1F9A5, 0x1F9AA, prExtendedPictographic}, // E12.0 [6] (🦥..🦪) sloth..oyster - {0x1F9AB, 0x1F9AD, prExtendedPictographic}, // E13.0 [3] (🦫..🦭) beaver..seal - {0x1F9AE, 0x1F9AF, prExtendedPictographic}, // E12.0 [2] (🦮..🦯) guide dog..white cane - {0x1F9B0, 0x1F9B9, prExtendedPictographic}, // E11.0 [10] (🦰..🦹) red hair..supervillain - {0x1F9BA, 0x1F9BF, prExtendedPictographic}, // E12.0 [6] (🦺..🦿) safety vest..mechanical leg - {0x1F9C0, 0x1F9C0, prExtendedPictographic}, // E1.0 [1] (🧀) cheese wedge - {0x1F9C1, 0x1F9C2, prExtendedPictographic}, // E11.0 [2] (🧁..🧂) cupcake..salt - {0x1F9C3, 0x1F9CA, prExtendedPictographic}, // E12.0 [8] (🧃..🧊) beverage box..ice - {0x1F9CB, 0x1F9CB, prExtendedPictographic}, // E13.0 [1] (🧋) bubble tea - {0x1F9CC, 0x1F9CC, prExtendedPictographic}, // E14.0 [1] (🧌) troll - {0x1F9CD, 0x1F9CF, prExtendedPictographic}, // E12.0 [3] (🧍..🧏) person standing..deaf person - {0x1F9D0, 0x1F9E6, prExtendedPictographic}, // E5.0 [23] (🧐..🧦) face with monocle..socks - {0x1F9E7, 0x1F9FF, prExtendedPictographic}, // E11.0 [25] (🧧..🧿) red envelope..nazar amulet - {0x1FA00, 0x1FA6F, prExtendedPictographic}, // E0.0 [112] (🨀..🩯) NEUTRAL CHESS KING.. - {0x1FA70, 0x1FA73, prExtendedPictographic}, // E12.0 [4] (🩰..🩳) ballet shoes..shorts - {0x1FA74, 0x1FA74, prExtendedPictographic}, // E13.0 [1] (🩴) thong sandal - {0x1FA75, 0x1FA77, prExtendedPictographic}, // E15.0 [3] (🩵..🩷) light blue heart..pink heart - {0x1FA78, 0x1FA7A, prExtendedPictographic}, // E12.0 [3] (🩸..🩺) drop of blood..stethoscope - {0x1FA7B, 0x1FA7C, prExtendedPictographic}, // E14.0 [2] (🩻..🩼) x-ray..crutch - {0x1FA7D, 0x1FA7F, prExtendedPictographic}, // E0.0 [3] (🩽..🩿) .. - {0x1FA80, 0x1FA82, prExtendedPictographic}, // E12.0 [3] (🪀..🪂) yo-yo..parachute - {0x1FA83, 0x1FA86, prExtendedPictographic}, // E13.0 [4] (🪃..🪆) boomerang..nesting dolls - {0x1FA87, 0x1FA88, prExtendedPictographic}, // E15.0 [2] (🪇..🪈) maracas..flute - {0x1FA89, 0x1FA8F, prExtendedPictographic}, // E0.0 [7] (🪉..🪏) .. - {0x1FA90, 0x1FA95, prExtendedPictographic}, // E12.0 [6] (🪐..🪕) ringed planet..banjo - {0x1FA96, 0x1FAA8, prExtendedPictographic}, // E13.0 [19] (🪖..🪨) military helmet..rock - {0x1FAA9, 0x1FAAC, prExtendedPictographic}, // E14.0 [4] (🪩..🪬) mirror ball..hamsa - {0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E15.0 [3] (🪭..🪯) folding hand fan..khanda - {0x1FAB0, 0x1FAB6, prExtendedPictographic}, // E13.0 [7] (🪰..🪶) fly..feather - {0x1FAB7, 0x1FABA, prExtendedPictographic}, // E14.0 [4] (🪷..🪺) lotus..nest with eggs - {0x1FABB, 0x1FABD, prExtendedPictographic}, // E15.0 [3] (🪻..🪽) hyacinth..wing - {0x1FABE, 0x1FABE, prExtendedPictographic}, // E0.0 [1] (🪾) - {0x1FABF, 0x1FABF, prExtendedPictographic}, // E15.0 [1] (🪿) goose - {0x1FAC0, 0x1FAC2, prExtendedPictographic}, // E13.0 [3] (🫀..🫂) anatomical heart..people hugging - {0x1FAC3, 0x1FAC5, prExtendedPictographic}, // E14.0 [3] (🫃..🫅) pregnant man..person with crown - {0x1FAC6, 0x1FACD, prExtendedPictographic}, // E0.0 [8] (🫆..🫍) .. - {0x1FACE, 0x1FACF, prExtendedPictographic}, // E15.0 [2] (🫎..🫏) moose..donkey - {0x1FAD0, 0x1FAD6, prExtendedPictographic}, // E13.0 [7] (🫐..🫖) blueberries..teapot - {0x1FAD7, 0x1FAD9, prExtendedPictographic}, // E14.0 [3] (🫗..🫙) pouring liquid..jar - {0x1FADA, 0x1FADB, prExtendedPictographic}, // E15.0 [2] (🫚..🫛) ginger root..pea pod - {0x1FADC, 0x1FADF, prExtendedPictographic}, // E0.0 [4] (🫜..🫟) .. - {0x1FAE0, 0x1FAE7, prExtendedPictographic}, // E14.0 [8] (🫠..🫧) melting face..bubbles - {0x1FAE8, 0x1FAE8, prExtendedPictographic}, // E15.0 [1] (🫨) shaking face - {0x1FAE9, 0x1FAEF, prExtendedPictographic}, // E0.0 [7] (🫩..🫯) .. - {0x1FAF0, 0x1FAF6, prExtendedPictographic}, // E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands - {0x1FAF7, 0x1FAF8, prExtendedPictographic}, // E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand - {0x1FAF9, 0x1FAFF, prExtendedPictographic}, // E0.0 [7] (🫹..🫿) .. - {0x1FC00, 0x1FFFD, prExtendedPictographic}, // E0.0[1022] (🰀..🿽) .. - {0xE0000, 0xE0000, prControl}, // Cn - {0xE0001, 0xE0001, prControl}, // Cf LANGUAGE TAG - {0xE0002, 0xE001F, prControl}, // Cn [30] .. - {0xE0020, 0xE007F, prExtend}, // Cf [96] TAG SPACE..CANCEL TAG - {0xE0080, 0xE00FF, prControl}, // Cn [128] .. - {0xE0100, 0xE01EF, prExtend}, // Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 - {0xE01F0, 0xE0FFF, prControl}, // Cn [3600] .. -} diff --git a/vendor/github.com/rivo/uniseg/graphemerules.go b/vendor/github.com/rivo/uniseg/graphemerules.go deleted file mode 100644 index 5d399d2..0000000 --- a/vendor/github.com/rivo/uniseg/graphemerules.go +++ /dev/null @@ -1,176 +0,0 @@ -package uniseg - -// The states of the grapheme cluster parser. -const ( - grAny = iota - grCR - grControlLF - grL - grLVV - grLVTT - grPrepend - grExtendedPictographic - grExtendedPictographicZWJ - grRIOdd - grRIEven -) - -// The grapheme cluster parser's breaking instructions. -const ( - grNoBoundary = iota - grBoundary -) - -// grTransitions implements the grapheme cluster parser's state transitions. -// Maps state and property to a new state, a breaking instruction, and rule -// number. The breaking instruction always refers to the boundary between the -// last and next code point. Returns negative values if no transition is found. -// -// This function is used as follows: -// -// 1. Find specific state + specific property. Stop if found. -// 2. Find specific state + any property. -// 3. Find any state + specific property. -// 4. If only (2) or (3) (but not both) was found, stop. -// 5. If both (2) and (3) were found, use state from (3) and breaking instruction -// from the transition with the lower rule number, prefer (3) if rule numbers -// are equal. Stop. -// 6. Assume grAny and grBoundary. -// -// Unicode version 15.0.0. -func grTransitions(state, prop int) (newState int, newProp int, boundary int) { - // It turns out that using a big switch statement is much faster than using - // a map. - - switch uint64(state) | uint64(prop)<<32 { - // GB5 - case grAny | prCR<<32: - return grCR, grBoundary, 50 - case grAny | prLF<<32: - return grControlLF, grBoundary, 50 - case grAny | prControl<<32: - return grControlLF, grBoundary, 50 - - // GB4 - case grCR | prAny<<32: - return grAny, grBoundary, 40 - case grControlLF | prAny<<32: - return grAny, grBoundary, 40 - - // GB3 - case grCR | prLF<<32: - return grControlLF, grNoBoundary, 30 - - // GB6 - case grAny | prL<<32: - return grL, grBoundary, 9990 - case grL | prL<<32: - return grL, grNoBoundary, 60 - case grL | prV<<32: - return grLVV, grNoBoundary, 60 - case grL | prLV<<32: - return grLVV, grNoBoundary, 60 - case grL | prLVT<<32: - return grLVTT, grNoBoundary, 60 - - // GB7 - case grAny | prLV<<32: - return grLVV, grBoundary, 9990 - case grAny | prV<<32: - return grLVV, grBoundary, 9990 - case grLVV | prV<<32: - return grLVV, grNoBoundary, 70 - case grLVV | prT<<32: - return grLVTT, grNoBoundary, 70 - - // GB8 - case grAny | prLVT<<32: - return grLVTT, grBoundary, 9990 - case grAny | prT<<32: - return grLVTT, grBoundary, 9990 - case grLVTT | prT<<32: - return grLVTT, grNoBoundary, 80 - - // GB9 - case grAny | prExtend<<32: - return grAny, grNoBoundary, 90 - case grAny | prZWJ<<32: - return grAny, grNoBoundary, 90 - - // GB9a - case grAny | prSpacingMark<<32: - return grAny, grNoBoundary, 91 - - // GB9b - case grAny | prPrepend<<32: - return grPrepend, grBoundary, 9990 - case grPrepend | prAny<<32: - return grAny, grNoBoundary, 92 - - // GB11 - case grAny | prExtendedPictographic<<32: - return grExtendedPictographic, grBoundary, 9990 - case grExtendedPictographic | prExtend<<32: - return grExtendedPictographic, grNoBoundary, 110 - case grExtendedPictographic | prZWJ<<32: - return grExtendedPictographicZWJ, grNoBoundary, 110 - case grExtendedPictographicZWJ | prExtendedPictographic<<32: - return grExtendedPictographic, grNoBoundary, 110 - - // GB12 / GB13 - case grAny | prRegionalIndicator<<32: - return grRIOdd, grBoundary, 9990 - case grRIOdd | prRegionalIndicator<<32: - return grRIEven, grNoBoundary, 120 - case grRIEven | prRegionalIndicator<<32: - return grRIOdd, grBoundary, 120 - default: - return -1, -1, -1 - } -} - -// transitionGraphemeState determines the new state of the grapheme cluster -// parser given the current state and the next code point. It also returns the -// code point's grapheme property (the value mapped by the [graphemeCodePoints] -// table) and whether a cluster boundary was detected. -func transitionGraphemeState(state int, r rune) (newState, prop int, boundary bool) { - // Determine the property of the next character. - prop = propertyGraphemes(r) - - // Find the applicable transition. - nextState, nextProp, _ := grTransitions(state, prop) - if nextState >= 0 { - // We have a specific transition. We'll use it. - return nextState, prop, nextProp == grBoundary - } - - // No specific transition found. Try the less specific ones. - anyPropState, anyPropProp, anyPropRule := grTransitions(state, prAny) - anyStateState, anyStateProp, anyStateRule := grTransitions(grAny, prop) - if anyPropState >= 0 && anyStateState >= 0 { - // Both apply. We'll use a mix (see comments for grTransitions). - newState = anyStateState - boundary = anyStateProp == grBoundary - if anyPropRule < anyStateRule { - boundary = anyPropProp == grBoundary - } - return - } - - if anyPropState >= 0 { - // We only have a specific state. - return anyPropState, prop, anyPropProp == grBoundary - // This branch will probably never be reached because okAnyState will - // always be true given the current transition map. But we keep it here - // for future modifications to the transition map where this may not be - // true anymore. - } - - if anyStateState >= 0 { - // We only have a specific property. - return anyStateState, prop, anyStateProp == grBoundary - } - - // No known transition. GB999: Any ÷ Any. - return grAny, prop, true -} diff --git a/vendor/github.com/rivo/uniseg/line.go b/vendor/github.com/rivo/uniseg/line.go deleted file mode 100644 index 7a46318..0000000 --- a/vendor/github.com/rivo/uniseg/line.go +++ /dev/null @@ -1,134 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// FirstLineSegment returns the prefix of the given byte slice after which a -// decision to break the string over to the next line can or must be made, -// according to the rules of [Unicode Standard Annex #14]. This is used to -// implement line breaking. -// -// Line breaking, also known as word wrapping, is the process of breaking a -// section of text into lines such that it will fit in the available width of a -// page, window or other display area. -// -// The returned "segment" may not be broken into smaller parts, unless no other -// breaking opportunities present themselves, in which case you may break by -// grapheme clusters (using the [FirstGraphemeCluster] function to determine the -// grapheme clusters). -// -// The "mustBreak" flag indicates whether you MUST break the line after the -// given segment (true), for example after newline characters, or you MAY break -// the line after the given segment (false). -// -// This function can be called continuously to extract all non-breaking sub-sets -// from a byte slice, as illustrated in the example below. -// -// If you don't know the current state, for example when calling the function -// for the first time, you must pass -1. For consecutive calls, pass the state -// and rest slice returned by the previous call. -// -// The "rest" slice is the sub-slice of the original byte slice "b" starting -// after the last byte of the identified line segment. If the length of the -// "rest" slice is 0, the entire byte slice "b" has been processed. The -// "segment" byte slice is the sub-slice of the input slice containing the -// identified line segment. -// -// Given an empty byte slice "b", the function returns nil values. -// -// Note that in accordance with [UAX #14 LB3], the final segment will end with -// "mustBreak" set to true. You can choose to ignore this by checking if the -// length of the "rest" slice is 0 and calling [HasTrailingLineBreak] or -// [HasTrailingLineBreakInString] on the last rune. -// -// Note also that this algorithm may break within grapheme clusters. This is -// addressed in Section 8.2 Example 6 of UAX #14. To avoid this, you can use -// the [Step] function instead. -// -// [Unicode Standard Annex #14]: https://www.unicode.org/reports/tr14/ -// [UAX #14 LB3]: https://www.unicode.org/reports/tr14/#Algorithm -func FirstLineSegment(b []byte, state int) (segment, rest []byte, mustBreak bool, newState int) { - // An empty byte slice returns nothing. - if len(b) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRune(b) - if len(b) <= length { // If we're already past the end, there is nothing else to parse. - return b, nil, true, lbAny // LB3. - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionLineBreakState(state, r, b[length:], "") - } - - // Transition until we find a boundary. - var boundary int - for { - r, l := utf8.DecodeRune(b[length:]) - state, boundary = transitionLineBreakState(state, r, b[length+l:], "") - - if boundary != LineDontBreak { - return b[:length], b[length:], boundary == LineMustBreak, state - } - - length += l - if len(b) <= length { - return b, nil, true, lbAny // LB3 - } - } -} - -// FirstLineSegmentInString is like [FirstLineSegment] but its input and outputs -// are strings. -func FirstLineSegmentInString(str string, state int) (segment, rest string, mustBreak bool, newState int) { - // An empty byte slice returns nothing. - if len(str) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRuneInString(str) - if len(str) <= length { // If we're already past the end, there is nothing else to parse. - return str, "", true, lbAny // LB3. - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionLineBreakState(state, r, nil, str[length:]) - } - - // Transition until we find a boundary. - var boundary int - for { - r, l := utf8.DecodeRuneInString(str[length:]) - state, boundary = transitionLineBreakState(state, r, nil, str[length+l:]) - - if boundary != LineDontBreak { - return str[:length], str[length:], boundary == LineMustBreak, state - } - - length += l - if len(str) <= length { - return str, "", true, lbAny // LB3. - } - } -} - -// HasTrailingLineBreak returns true if the last rune in the given byte slice is -// one of the hard line break code points defined in LB4 and LB5 of [UAX #14]. -// -// [UAX #14]: https://www.unicode.org/reports/tr14/#Algorithm -func HasTrailingLineBreak(b []byte) bool { - r, _ := utf8.DecodeLastRune(b) - property, _ := propertyLineBreak(r) - return property == prBK || property == prCR || property == prLF || property == prNL -} - -// HasTrailingLineBreakInString is like [HasTrailingLineBreak] but for a string. -func HasTrailingLineBreakInString(str string) bool { - r, _ := utf8.DecodeLastRuneInString(str) - property, _ := propertyLineBreak(r) - return property == prBK || property == prCR || property == prLF || property == prNL -} diff --git a/vendor/github.com/rivo/uniseg/lineproperties.go b/vendor/github.com/rivo/uniseg/lineproperties.go deleted file mode 100644 index ac7fac4..0000000 --- a/vendor/github.com/rivo/uniseg/lineproperties.go +++ /dev/null @@ -1,3554 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// lineBreakCodePoints are taken from -// https://www.unicode.org/Public/15.0.0/ucd/LineBreak.txt -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var lineBreakCodePoints = [][4]int{ - {0x0000, 0x0008, prCM, gcCc}, // [9] .. - {0x0009, 0x0009, prBA, gcCc}, // - {0x000A, 0x000A, prLF, gcCc}, // - {0x000B, 0x000C, prBK, gcCc}, // [2] .. - {0x000D, 0x000D, prCR, gcCc}, // - {0x000E, 0x001F, prCM, gcCc}, // [18] .. - {0x0020, 0x0020, prSP, gcZs}, // SPACE - {0x0021, 0x0021, prEX, gcPo}, // EXCLAMATION MARK - {0x0022, 0x0022, prQU, gcPo}, // QUOTATION MARK - {0x0023, 0x0023, prAL, gcPo}, // NUMBER SIGN - {0x0024, 0x0024, prPR, gcSc}, // DOLLAR SIGN - {0x0025, 0x0025, prPO, gcPo}, // PERCENT SIGN - {0x0026, 0x0026, prAL, gcPo}, // AMPERSAND - {0x0027, 0x0027, prQU, gcPo}, // APOSTROPHE - {0x0028, 0x0028, prOP, gcPs}, // LEFT PARENTHESIS - {0x0029, 0x0029, prCP, gcPe}, // RIGHT PARENTHESIS - {0x002A, 0x002A, prAL, gcPo}, // ASTERISK - {0x002B, 0x002B, prPR, gcSm}, // PLUS SIGN - {0x002C, 0x002C, prIS, gcPo}, // COMMA - {0x002D, 0x002D, prHY, gcPd}, // HYPHEN-MINUS - {0x002E, 0x002E, prIS, gcPo}, // FULL STOP - {0x002F, 0x002F, prSY, gcPo}, // SOLIDUS - {0x0030, 0x0039, prNU, gcNd}, // [10] DIGIT ZERO..DIGIT NINE - {0x003A, 0x003B, prIS, gcPo}, // [2] COLON..SEMICOLON - {0x003C, 0x003E, prAL, gcSm}, // [3] LESS-THAN SIGN..GREATER-THAN SIGN - {0x003F, 0x003F, prEX, gcPo}, // QUESTION MARK - {0x0040, 0x0040, prAL, gcPo}, // COMMERCIAL AT - {0x0041, 0x005A, prAL, gcLu}, // [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z - {0x005B, 0x005B, prOP, gcPs}, // LEFT SQUARE BRACKET - {0x005C, 0x005C, prPR, gcPo}, // REVERSE SOLIDUS - {0x005D, 0x005D, prCP, gcPe}, // RIGHT SQUARE BRACKET - {0x005E, 0x005E, prAL, gcSk}, // CIRCUMFLEX ACCENT - {0x005F, 0x005F, prAL, gcPc}, // LOW LINE - {0x0060, 0x0060, prAL, gcSk}, // GRAVE ACCENT - {0x0061, 0x007A, prAL, gcLl}, // [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z - {0x007B, 0x007B, prOP, gcPs}, // LEFT CURLY BRACKET - {0x007C, 0x007C, prBA, gcSm}, // VERTICAL LINE - {0x007D, 0x007D, prCL, gcPe}, // RIGHT CURLY BRACKET - {0x007E, 0x007E, prAL, gcSm}, // TILDE - {0x007F, 0x007F, prCM, gcCc}, // - {0x0080, 0x0084, prCM, gcCc}, // [5] .. - {0x0085, 0x0085, prNL, gcCc}, // - {0x0086, 0x009F, prCM, gcCc}, // [26] .. - {0x00A0, 0x00A0, prGL, gcZs}, // NO-BREAK SPACE - {0x00A1, 0x00A1, prOP, gcPo}, // INVERTED EXCLAMATION MARK - {0x00A2, 0x00A2, prPO, gcSc}, // CENT SIGN - {0x00A3, 0x00A5, prPR, gcSc}, // [3] POUND SIGN..YEN SIGN - {0x00A6, 0x00A6, prAL, gcSo}, // BROKEN BAR - {0x00A7, 0x00A7, prAI, gcPo}, // SECTION SIGN - {0x00A8, 0x00A8, prAI, gcSk}, // DIAERESIS - {0x00A9, 0x00A9, prAL, gcSo}, // COPYRIGHT SIGN - {0x00AA, 0x00AA, prAI, gcLo}, // FEMININE ORDINAL INDICATOR - {0x00AB, 0x00AB, prQU, gcPi}, // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00AC, 0x00AC, prAL, gcSm}, // NOT SIGN - {0x00AD, 0x00AD, prBA, gcCf}, // SOFT HYPHEN - {0x00AE, 0x00AE, prAL, gcSo}, // REGISTERED SIGN - {0x00AF, 0x00AF, prAL, gcSk}, // MACRON - {0x00B0, 0x00B0, prPO, gcSo}, // DEGREE SIGN - {0x00B1, 0x00B1, prPR, gcSm}, // PLUS-MINUS SIGN - {0x00B2, 0x00B3, prAI, gcNo}, // [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE - {0x00B4, 0x00B4, prBB, gcSk}, // ACUTE ACCENT - {0x00B5, 0x00B5, prAL, gcLl}, // MICRO SIGN - {0x00B6, 0x00B7, prAI, gcPo}, // [2] PILCROW SIGN..MIDDLE DOT - {0x00B8, 0x00B8, prAI, gcSk}, // CEDILLA - {0x00B9, 0x00B9, prAI, gcNo}, // SUPERSCRIPT ONE - {0x00BA, 0x00BA, prAI, gcLo}, // MASCULINE ORDINAL INDICATOR - {0x00BB, 0x00BB, prQU, gcPf}, // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00BC, 0x00BE, prAI, gcNo}, // [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS - {0x00BF, 0x00BF, prOP, gcPo}, // INVERTED QUESTION MARK - {0x00C0, 0x00D6, prAL, gcLu}, // [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS - {0x00D7, 0x00D7, prAI, gcSm}, // MULTIPLICATION SIGN - {0x00D8, 0x00F6, prAL, gcLC}, // [31] LATIN CAPITAL LETTER O WITH STROKE..LATIN SMALL LETTER O WITH DIAERESIS - {0x00F7, 0x00F7, prAI, gcSm}, // DIVISION SIGN - {0x00F8, 0x00FF, prAL, gcLl}, // [8] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER Y WITH DIAERESIS - {0x0100, 0x017F, prAL, gcLC}, // [128] LATIN CAPITAL LETTER A WITH MACRON..LATIN SMALL LETTER LONG S - {0x0180, 0x01BA, prAL, gcLC}, // [59] LATIN SMALL LETTER B WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL - {0x01BB, 0x01BB, prAL, gcLo}, // LATIN LETTER TWO WITH STROKE - {0x01BC, 0x01BF, prAL, gcLC}, // [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN - {0x01C0, 0x01C3, prAL, gcLo}, // [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK - {0x01C4, 0x024F, prAL, gcLC}, // [140] LATIN CAPITAL LETTER DZ WITH CARON..LATIN SMALL LETTER Y WITH STROKE - {0x0250, 0x0293, prAL, gcLl}, // [68] LATIN SMALL LETTER TURNED A..LATIN SMALL LETTER EZH WITH CURL - {0x0294, 0x0294, prAL, gcLo}, // LATIN LETTER GLOTTAL STOP - {0x0295, 0x02AF, prAL, gcLl}, // [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL - {0x02B0, 0x02C1, prAL, gcLm}, // [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP - {0x02C2, 0x02C5, prAL, gcSk}, // [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD - {0x02C6, 0x02C6, prAL, gcLm}, // MODIFIER LETTER CIRCUMFLEX ACCENT - {0x02C7, 0x02C7, prAI, gcLm}, // CARON - {0x02C8, 0x02C8, prBB, gcLm}, // MODIFIER LETTER VERTICAL LINE - {0x02C9, 0x02CB, prAI, gcLm}, // [3] MODIFIER LETTER MACRON..MODIFIER LETTER GRAVE ACCENT - {0x02CC, 0x02CC, prBB, gcLm}, // MODIFIER LETTER LOW VERTICAL LINE - {0x02CD, 0x02CD, prAI, gcLm}, // MODIFIER LETTER LOW MACRON - {0x02CE, 0x02CF, prAL, gcLm}, // [2] MODIFIER LETTER LOW GRAVE ACCENT..MODIFIER LETTER LOW ACUTE ACCENT - {0x02D0, 0x02D0, prAI, gcLm}, // MODIFIER LETTER TRIANGULAR COLON - {0x02D1, 0x02D1, prAL, gcLm}, // MODIFIER LETTER HALF TRIANGULAR COLON - {0x02D2, 0x02D7, prAL, gcSk}, // [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN - {0x02D8, 0x02DB, prAI, gcSk}, // [4] BREVE..OGONEK - {0x02DC, 0x02DC, prAL, gcSk}, // SMALL TILDE - {0x02DD, 0x02DD, prAI, gcSk}, // DOUBLE ACUTE ACCENT - {0x02DE, 0x02DE, prAL, gcSk}, // MODIFIER LETTER RHOTIC HOOK - {0x02DF, 0x02DF, prBB, gcSk}, // MODIFIER LETTER CROSS ACCENT - {0x02E0, 0x02E4, prAL, gcLm}, // [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP - {0x02E5, 0x02EB, prAL, gcSk}, // [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK - {0x02EC, 0x02EC, prAL, gcLm}, // MODIFIER LETTER VOICING - {0x02ED, 0x02ED, prAL, gcSk}, // MODIFIER LETTER UNASPIRATED - {0x02EE, 0x02EE, prAL, gcLm}, // MODIFIER LETTER DOUBLE APOSTROPHE - {0x02EF, 0x02FF, prAL, gcSk}, // [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW - {0x0300, 0x034E, prCM, gcMn}, // [79] COMBINING GRAVE ACCENT..COMBINING UPWARDS ARROW BELOW - {0x034F, 0x034F, prGL, gcMn}, // COMBINING GRAPHEME JOINER - {0x0350, 0x035B, prCM, gcMn}, // [12] COMBINING RIGHT ARROWHEAD ABOVE..COMBINING ZIGZAG ABOVE - {0x035C, 0x0362, prGL, gcMn}, // [7] COMBINING DOUBLE BREVE BELOW..COMBINING DOUBLE RIGHTWARDS ARROW BELOW - {0x0363, 0x036F, prCM, gcMn}, // [13] COMBINING LATIN SMALL LETTER A..COMBINING LATIN SMALL LETTER X - {0x0370, 0x0373, prAL, gcLC}, // [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI - {0x0374, 0x0374, prAL, gcLm}, // GREEK NUMERAL SIGN - {0x0375, 0x0375, prAL, gcSk}, // GREEK LOWER NUMERAL SIGN - {0x0376, 0x0377, prAL, gcLC}, // [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA - {0x037A, 0x037A, prAL, gcLm}, // GREEK YPOGEGRAMMENI - {0x037B, 0x037D, prAL, gcLl}, // [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x037E, 0x037E, prIS, gcPo}, // GREEK QUESTION MARK - {0x037F, 0x037F, prAL, gcLu}, // GREEK CAPITAL LETTER YOT - {0x0384, 0x0385, prAL, gcSk}, // [2] GREEK TONOS..GREEK DIALYTIKA TONOS - {0x0386, 0x0386, prAL, gcLu}, // GREEK CAPITAL LETTER ALPHA WITH TONOS - {0x0387, 0x0387, prAL, gcPo}, // GREEK ANO TELEIA - {0x0388, 0x038A, prAL, gcLu}, // [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS - {0x038C, 0x038C, prAL, gcLu}, // GREEK CAPITAL LETTER OMICRON WITH TONOS - {0x038E, 0x03A1, prAL, gcLC}, // [20] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER RHO - {0x03A3, 0x03F5, prAL, gcLC}, // [83] GREEK CAPITAL LETTER SIGMA..GREEK LUNATE EPSILON SYMBOL - {0x03F6, 0x03F6, prAL, gcSm}, // GREEK REVERSED LUNATE EPSILON SYMBOL - {0x03F7, 0x03FF, prAL, gcLC}, // [9] GREEK CAPITAL LETTER SHO..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x0400, 0x0481, prAL, gcLC}, // [130] CYRILLIC CAPITAL LETTER IE WITH GRAVE..CYRILLIC SMALL LETTER KOPPA - {0x0482, 0x0482, prAL, gcSo}, // CYRILLIC THOUSANDS SIGN - {0x0483, 0x0487, prCM, gcMn}, // [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE - {0x0488, 0x0489, prCM, gcMe}, // [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN - {0x048A, 0x04FF, prAL, gcLC}, // [118] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER HA WITH STROKE - {0x0500, 0x052F, prAL, gcLC}, // [48] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER EL WITH DESCENDER - {0x0531, 0x0556, prAL, gcLu}, // [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH - {0x0559, 0x0559, prAL, gcLm}, // ARMENIAN MODIFIER LETTER LEFT HALF RING - {0x055A, 0x055F, prAL, gcPo}, // [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK - {0x0560, 0x0588, prAL, gcLl}, // [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE - {0x0589, 0x0589, prIS, gcPo}, // ARMENIAN FULL STOP - {0x058A, 0x058A, prBA, gcPd}, // ARMENIAN HYPHEN - {0x058D, 0x058E, prAL, gcSo}, // [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN - {0x058F, 0x058F, prPR, gcSc}, // ARMENIAN DRAM SIGN - {0x0591, 0x05BD, prCM, gcMn}, // [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG - {0x05BE, 0x05BE, prBA, gcPd}, // HEBREW PUNCTUATION MAQAF - {0x05BF, 0x05BF, prCM, gcMn}, // HEBREW POINT RAFE - {0x05C0, 0x05C0, prAL, gcPo}, // HEBREW PUNCTUATION PASEQ - {0x05C1, 0x05C2, prCM, gcMn}, // [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT - {0x05C3, 0x05C3, prAL, gcPo}, // HEBREW PUNCTUATION SOF PASUQ - {0x05C4, 0x05C5, prCM, gcMn}, // [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT - {0x05C6, 0x05C6, prEX, gcPo}, // HEBREW PUNCTUATION NUN HAFUKHA - {0x05C7, 0x05C7, prCM, gcMn}, // HEBREW POINT QAMATS QATAN - {0x05D0, 0x05EA, prHL, gcLo}, // [27] HEBREW LETTER ALEF..HEBREW LETTER TAV - {0x05EF, 0x05F2, prHL, gcLo}, // [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD - {0x05F3, 0x05F4, prAL, gcPo}, // [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM - {0x0600, 0x0605, prAL, gcCf}, // [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE - {0x0606, 0x0608, prAL, gcSm}, // [3] ARABIC-INDIC CUBE ROOT..ARABIC RAY - {0x0609, 0x060A, prPO, gcPo}, // [2] ARABIC-INDIC PER MILLE SIGN..ARABIC-INDIC PER TEN THOUSAND SIGN - {0x060B, 0x060B, prPO, gcSc}, // AFGHANI SIGN - {0x060C, 0x060D, prIS, gcPo}, // [2] ARABIC COMMA..ARABIC DATE SEPARATOR - {0x060E, 0x060F, prAL, gcSo}, // [2] ARABIC POETIC VERSE SIGN..ARABIC SIGN MISRA - {0x0610, 0x061A, prCM, gcMn}, // [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA - {0x061B, 0x061B, prEX, gcPo}, // ARABIC SEMICOLON - {0x061C, 0x061C, prCM, gcCf}, // ARABIC LETTER MARK - {0x061D, 0x061F, prEX, gcPo}, // [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK - {0x0620, 0x063F, prAL, gcLo}, // [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE - {0x0640, 0x0640, prAL, gcLm}, // ARABIC TATWEEL - {0x0641, 0x064A, prAL, gcLo}, // [10] ARABIC LETTER FEH..ARABIC LETTER YEH - {0x064B, 0x065F, prCM, gcMn}, // [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW - {0x0660, 0x0669, prNU, gcNd}, // [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE - {0x066A, 0x066A, prPO, gcPo}, // ARABIC PERCENT SIGN - {0x066B, 0x066C, prNU, gcPo}, // [2] ARABIC DECIMAL SEPARATOR..ARABIC THOUSANDS SEPARATOR - {0x066D, 0x066D, prAL, gcPo}, // ARABIC FIVE POINTED STAR - {0x066E, 0x066F, prAL, gcLo}, // [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF - {0x0670, 0x0670, prCM, gcMn}, // ARABIC LETTER SUPERSCRIPT ALEF - {0x0671, 0x06D3, prAL, gcLo}, // [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE - {0x06D4, 0x06D4, prEX, gcPo}, // ARABIC FULL STOP - {0x06D5, 0x06D5, prAL, gcLo}, // ARABIC LETTER AE - {0x06D6, 0x06DC, prCM, gcMn}, // [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN - {0x06DD, 0x06DD, prAL, gcCf}, // ARABIC END OF AYAH - {0x06DE, 0x06DE, prAL, gcSo}, // ARABIC START OF RUB EL HIZB - {0x06DF, 0x06E4, prCM, gcMn}, // [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA - {0x06E5, 0x06E6, prAL, gcLm}, // [2] ARABIC SMALL WAW..ARABIC SMALL YEH - {0x06E7, 0x06E8, prCM, gcMn}, // [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON - {0x06E9, 0x06E9, prAL, gcSo}, // ARABIC PLACE OF SAJDAH - {0x06EA, 0x06ED, prCM, gcMn}, // [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM - {0x06EE, 0x06EF, prAL, gcLo}, // [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V - {0x06F0, 0x06F9, prNU, gcNd}, // [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE - {0x06FA, 0x06FC, prAL, gcLo}, // [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW - {0x06FD, 0x06FE, prAL, gcSo}, // [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN - {0x06FF, 0x06FF, prAL, gcLo}, // ARABIC LETTER HEH WITH INVERTED V - {0x0700, 0x070D, prAL, gcPo}, // [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS - {0x070F, 0x070F, prAL, gcCf}, // SYRIAC ABBREVIATION MARK - {0x0710, 0x0710, prAL, gcLo}, // SYRIAC LETTER ALAPH - {0x0711, 0x0711, prCM, gcMn}, // SYRIAC LETTER SUPERSCRIPT ALAPH - {0x0712, 0x072F, prAL, gcLo}, // [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH - {0x0730, 0x074A, prCM, gcMn}, // [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH - {0x074D, 0x074F, prAL, gcLo}, // [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE - {0x0750, 0x077F, prAL, gcLo}, // [48] ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS ABOVE - {0x0780, 0x07A5, prAL, gcLo}, // [38] THAANA LETTER HAA..THAANA LETTER WAAVU - {0x07A6, 0x07B0, prCM, gcMn}, // [11] THAANA ABAFILI..THAANA SUKUN - {0x07B1, 0x07B1, prAL, gcLo}, // THAANA LETTER NAA - {0x07C0, 0x07C9, prNU, gcNd}, // [10] NKO DIGIT ZERO..NKO DIGIT NINE - {0x07CA, 0x07EA, prAL, gcLo}, // [33] NKO LETTER A..NKO LETTER JONA RA - {0x07EB, 0x07F3, prCM, gcMn}, // [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE - {0x07F4, 0x07F5, prAL, gcLm}, // [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE - {0x07F6, 0x07F6, prAL, gcSo}, // NKO SYMBOL OO DENNEN - {0x07F7, 0x07F7, prAL, gcPo}, // NKO SYMBOL GBAKURUNEN - {0x07F8, 0x07F8, prIS, gcPo}, // NKO COMMA - {0x07F9, 0x07F9, prEX, gcPo}, // NKO EXCLAMATION MARK - {0x07FA, 0x07FA, prAL, gcLm}, // NKO LAJANYALAN - {0x07FD, 0x07FD, prCM, gcMn}, // NKO DANTAYALAN - {0x07FE, 0x07FF, prPR, gcSc}, // [2] NKO DOROME SIGN..NKO TAMAN SIGN - {0x0800, 0x0815, prAL, gcLo}, // [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF - {0x0816, 0x0819, prCM, gcMn}, // [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH - {0x081A, 0x081A, prAL, gcLm}, // SAMARITAN MODIFIER LETTER EPENTHETIC YUT - {0x081B, 0x0823, prCM, gcMn}, // [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A - {0x0824, 0x0824, prAL, gcLm}, // SAMARITAN MODIFIER LETTER SHORT A - {0x0825, 0x0827, prCM, gcMn}, // [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U - {0x0828, 0x0828, prAL, gcLm}, // SAMARITAN MODIFIER LETTER I - {0x0829, 0x082D, prCM, gcMn}, // [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA - {0x0830, 0x083E, prAL, gcPo}, // [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU - {0x0840, 0x0858, prAL, gcLo}, // [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN - {0x0859, 0x085B, prCM, gcMn}, // [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK - {0x085E, 0x085E, prAL, gcPo}, // MANDAIC PUNCTUATION - {0x0860, 0x086A, prAL, gcLo}, // [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA - {0x0870, 0x0887, prAL, gcLo}, // [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT - {0x0888, 0x0888, prAL, gcSk}, // ARABIC RAISED ROUND DOT - {0x0889, 0x088E, prAL, gcLo}, // [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL - {0x0890, 0x0891, prAL, gcCf}, // [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE - {0x0898, 0x089F, prCM, gcMn}, // [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA - {0x08A0, 0x08C8, prAL, gcLo}, // [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF - {0x08C9, 0x08C9, prAL, gcLm}, // ARABIC SMALL FARSI YEH - {0x08CA, 0x08E1, prCM, gcMn}, // [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA - {0x08E2, 0x08E2, prAL, gcCf}, // ARABIC DISPUTED END OF AYAH - {0x08E3, 0x08FF, prCM, gcMn}, // [29] ARABIC TURNED DAMMA BELOW..ARABIC MARK SIDEWAYS NOON GHUNNA - {0x0900, 0x0902, prCM, gcMn}, // [3] DEVANAGARI SIGN INVERTED CANDRABINDU..DEVANAGARI SIGN ANUSVARA - {0x0903, 0x0903, prCM, gcMc}, // DEVANAGARI SIGN VISARGA - {0x0904, 0x0939, prAL, gcLo}, // [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA - {0x093A, 0x093A, prCM, gcMn}, // DEVANAGARI VOWEL SIGN OE - {0x093B, 0x093B, prCM, gcMc}, // DEVANAGARI VOWEL SIGN OOE - {0x093C, 0x093C, prCM, gcMn}, // DEVANAGARI SIGN NUKTA - {0x093D, 0x093D, prAL, gcLo}, // DEVANAGARI SIGN AVAGRAHA - {0x093E, 0x0940, prCM, gcMc}, // [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II - {0x0941, 0x0948, prCM, gcMn}, // [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI - {0x0949, 0x094C, prCM, gcMc}, // [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU - {0x094D, 0x094D, prCM, gcMn}, // DEVANAGARI SIGN VIRAMA - {0x094E, 0x094F, prCM, gcMc}, // [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW - {0x0950, 0x0950, prAL, gcLo}, // DEVANAGARI OM - {0x0951, 0x0957, prCM, gcMn}, // [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE - {0x0958, 0x0961, prAL, gcLo}, // [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL - {0x0962, 0x0963, prCM, gcMn}, // [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL - {0x0964, 0x0965, prBA, gcPo}, // [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA - {0x0966, 0x096F, prNU, gcNd}, // [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE - {0x0970, 0x0970, prAL, gcPo}, // DEVANAGARI ABBREVIATION SIGN - {0x0971, 0x0971, prAL, gcLm}, // DEVANAGARI SIGN HIGH SPACING DOT - {0x0972, 0x097F, prAL, gcLo}, // [14] DEVANAGARI LETTER CANDRA A..DEVANAGARI LETTER BBA - {0x0980, 0x0980, prAL, gcLo}, // BENGALI ANJI - {0x0981, 0x0981, prCM, gcMn}, // BENGALI SIGN CANDRABINDU - {0x0982, 0x0983, prCM, gcMc}, // [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA - {0x0985, 0x098C, prAL, gcLo}, // [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L - {0x098F, 0x0990, prAL, gcLo}, // [2] BENGALI LETTER E..BENGALI LETTER AI - {0x0993, 0x09A8, prAL, gcLo}, // [22] BENGALI LETTER O..BENGALI LETTER NA - {0x09AA, 0x09B0, prAL, gcLo}, // [7] BENGALI LETTER PA..BENGALI LETTER RA - {0x09B2, 0x09B2, prAL, gcLo}, // BENGALI LETTER LA - {0x09B6, 0x09B9, prAL, gcLo}, // [4] BENGALI LETTER SHA..BENGALI LETTER HA - {0x09BC, 0x09BC, prCM, gcMn}, // BENGALI SIGN NUKTA - {0x09BD, 0x09BD, prAL, gcLo}, // BENGALI SIGN AVAGRAHA - {0x09BE, 0x09C0, prCM, gcMc}, // [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II - {0x09C1, 0x09C4, prCM, gcMn}, // [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR - {0x09C7, 0x09C8, prCM, gcMc}, // [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI - {0x09CB, 0x09CC, prCM, gcMc}, // [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU - {0x09CD, 0x09CD, prCM, gcMn}, // BENGALI SIGN VIRAMA - {0x09CE, 0x09CE, prAL, gcLo}, // BENGALI LETTER KHANDA TA - {0x09D7, 0x09D7, prCM, gcMc}, // BENGALI AU LENGTH MARK - {0x09DC, 0x09DD, prAL, gcLo}, // [2] BENGALI LETTER RRA..BENGALI LETTER RHA - {0x09DF, 0x09E1, prAL, gcLo}, // [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL - {0x09E2, 0x09E3, prCM, gcMn}, // [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL - {0x09E6, 0x09EF, prNU, gcNd}, // [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE - {0x09F0, 0x09F1, prAL, gcLo}, // [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL - {0x09F2, 0x09F3, prPO, gcSc}, // [2] BENGALI RUPEE MARK..BENGALI RUPEE SIGN - {0x09F4, 0x09F8, prAL, gcNo}, // [5] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY NUMERATOR ONE LESS THAN THE DENOMINATOR - {0x09F9, 0x09F9, prPO, gcNo}, // BENGALI CURRENCY DENOMINATOR SIXTEEN - {0x09FA, 0x09FA, prAL, gcSo}, // BENGALI ISSHAR - {0x09FB, 0x09FB, prPR, gcSc}, // BENGALI GANDA MARK - {0x09FC, 0x09FC, prAL, gcLo}, // BENGALI LETTER VEDIC ANUSVARA - {0x09FD, 0x09FD, prAL, gcPo}, // BENGALI ABBREVIATION SIGN - {0x09FE, 0x09FE, prCM, gcMn}, // BENGALI SANDHI MARK - {0x0A01, 0x0A02, prCM, gcMn}, // [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI - {0x0A03, 0x0A03, prCM, gcMc}, // GURMUKHI SIGN VISARGA - {0x0A05, 0x0A0A, prAL, gcLo}, // [6] GURMUKHI LETTER A..GURMUKHI LETTER UU - {0x0A0F, 0x0A10, prAL, gcLo}, // [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI - {0x0A13, 0x0A28, prAL, gcLo}, // [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA - {0x0A2A, 0x0A30, prAL, gcLo}, // [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA - {0x0A32, 0x0A33, prAL, gcLo}, // [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA - {0x0A35, 0x0A36, prAL, gcLo}, // [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA - {0x0A38, 0x0A39, prAL, gcLo}, // [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA - {0x0A3C, 0x0A3C, prCM, gcMn}, // GURMUKHI SIGN NUKTA - {0x0A3E, 0x0A40, prCM, gcMc}, // [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II - {0x0A41, 0x0A42, prCM, gcMn}, // [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU - {0x0A47, 0x0A48, prCM, gcMn}, // [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI - {0x0A4B, 0x0A4D, prCM, gcMn}, // [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA - {0x0A51, 0x0A51, prCM, gcMn}, // GURMUKHI SIGN UDAAT - {0x0A59, 0x0A5C, prAL, gcLo}, // [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA - {0x0A5E, 0x0A5E, prAL, gcLo}, // GURMUKHI LETTER FA - {0x0A66, 0x0A6F, prNU, gcNd}, // [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE - {0x0A70, 0x0A71, prCM, gcMn}, // [2] GURMUKHI TIPPI..GURMUKHI ADDAK - {0x0A72, 0x0A74, prAL, gcLo}, // [3] GURMUKHI IRI..GURMUKHI EK ONKAR - {0x0A75, 0x0A75, prCM, gcMn}, // GURMUKHI SIGN YAKASH - {0x0A76, 0x0A76, prAL, gcPo}, // GURMUKHI ABBREVIATION SIGN - {0x0A81, 0x0A82, prCM, gcMn}, // [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA - {0x0A83, 0x0A83, prCM, gcMc}, // GUJARATI SIGN VISARGA - {0x0A85, 0x0A8D, prAL, gcLo}, // [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E - {0x0A8F, 0x0A91, prAL, gcLo}, // [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O - {0x0A93, 0x0AA8, prAL, gcLo}, // [22] GUJARATI LETTER O..GUJARATI LETTER NA - {0x0AAA, 0x0AB0, prAL, gcLo}, // [7] GUJARATI LETTER PA..GUJARATI LETTER RA - {0x0AB2, 0x0AB3, prAL, gcLo}, // [2] GUJARATI LETTER LA..GUJARATI LETTER LLA - {0x0AB5, 0x0AB9, prAL, gcLo}, // [5] GUJARATI LETTER VA..GUJARATI LETTER HA - {0x0ABC, 0x0ABC, prCM, gcMn}, // GUJARATI SIGN NUKTA - {0x0ABD, 0x0ABD, prAL, gcLo}, // GUJARATI SIGN AVAGRAHA - {0x0ABE, 0x0AC0, prCM, gcMc}, // [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II - {0x0AC1, 0x0AC5, prCM, gcMn}, // [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E - {0x0AC7, 0x0AC8, prCM, gcMn}, // [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI - {0x0AC9, 0x0AC9, prCM, gcMc}, // GUJARATI VOWEL SIGN CANDRA O - {0x0ACB, 0x0ACC, prCM, gcMc}, // [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU - {0x0ACD, 0x0ACD, prCM, gcMn}, // GUJARATI SIGN VIRAMA - {0x0AD0, 0x0AD0, prAL, gcLo}, // GUJARATI OM - {0x0AE0, 0x0AE1, prAL, gcLo}, // [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL - {0x0AE2, 0x0AE3, prCM, gcMn}, // [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL - {0x0AE6, 0x0AEF, prNU, gcNd}, // [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE - {0x0AF0, 0x0AF0, prAL, gcPo}, // GUJARATI ABBREVIATION SIGN - {0x0AF1, 0x0AF1, prPR, gcSc}, // GUJARATI RUPEE SIGN - {0x0AF9, 0x0AF9, prAL, gcLo}, // GUJARATI LETTER ZHA - {0x0AFA, 0x0AFF, prCM, gcMn}, // [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE - {0x0B01, 0x0B01, prCM, gcMn}, // ORIYA SIGN CANDRABINDU - {0x0B02, 0x0B03, prCM, gcMc}, // [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA - {0x0B05, 0x0B0C, prAL, gcLo}, // [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L - {0x0B0F, 0x0B10, prAL, gcLo}, // [2] ORIYA LETTER E..ORIYA LETTER AI - {0x0B13, 0x0B28, prAL, gcLo}, // [22] ORIYA LETTER O..ORIYA LETTER NA - {0x0B2A, 0x0B30, prAL, gcLo}, // [7] ORIYA LETTER PA..ORIYA LETTER RA - {0x0B32, 0x0B33, prAL, gcLo}, // [2] ORIYA LETTER LA..ORIYA LETTER LLA - {0x0B35, 0x0B39, prAL, gcLo}, // [5] ORIYA LETTER VA..ORIYA LETTER HA - {0x0B3C, 0x0B3C, prCM, gcMn}, // ORIYA SIGN NUKTA - {0x0B3D, 0x0B3D, prAL, gcLo}, // ORIYA SIGN AVAGRAHA - {0x0B3E, 0x0B3E, prCM, gcMc}, // ORIYA VOWEL SIGN AA - {0x0B3F, 0x0B3F, prCM, gcMn}, // ORIYA VOWEL SIGN I - {0x0B40, 0x0B40, prCM, gcMc}, // ORIYA VOWEL SIGN II - {0x0B41, 0x0B44, prCM, gcMn}, // [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR - {0x0B47, 0x0B48, prCM, gcMc}, // [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI - {0x0B4B, 0x0B4C, prCM, gcMc}, // [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU - {0x0B4D, 0x0B4D, prCM, gcMn}, // ORIYA SIGN VIRAMA - {0x0B55, 0x0B56, prCM, gcMn}, // [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK - {0x0B57, 0x0B57, prCM, gcMc}, // ORIYA AU LENGTH MARK - {0x0B5C, 0x0B5D, prAL, gcLo}, // [2] ORIYA LETTER RRA..ORIYA LETTER RHA - {0x0B5F, 0x0B61, prAL, gcLo}, // [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL - {0x0B62, 0x0B63, prCM, gcMn}, // [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL - {0x0B66, 0x0B6F, prNU, gcNd}, // [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE - {0x0B70, 0x0B70, prAL, gcSo}, // ORIYA ISSHAR - {0x0B71, 0x0B71, prAL, gcLo}, // ORIYA LETTER WA - {0x0B72, 0x0B77, prAL, gcNo}, // [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS - {0x0B82, 0x0B82, prCM, gcMn}, // TAMIL SIGN ANUSVARA - {0x0B83, 0x0B83, prAL, gcLo}, // TAMIL SIGN VISARGA - {0x0B85, 0x0B8A, prAL, gcLo}, // [6] TAMIL LETTER A..TAMIL LETTER UU - {0x0B8E, 0x0B90, prAL, gcLo}, // [3] TAMIL LETTER E..TAMIL LETTER AI - {0x0B92, 0x0B95, prAL, gcLo}, // [4] TAMIL LETTER O..TAMIL LETTER KA - {0x0B99, 0x0B9A, prAL, gcLo}, // [2] TAMIL LETTER NGA..TAMIL LETTER CA - {0x0B9C, 0x0B9C, prAL, gcLo}, // TAMIL LETTER JA - {0x0B9E, 0x0B9F, prAL, gcLo}, // [2] TAMIL LETTER NYA..TAMIL LETTER TTA - {0x0BA3, 0x0BA4, prAL, gcLo}, // [2] TAMIL LETTER NNA..TAMIL LETTER TA - {0x0BA8, 0x0BAA, prAL, gcLo}, // [3] TAMIL LETTER NA..TAMIL LETTER PA - {0x0BAE, 0x0BB9, prAL, gcLo}, // [12] TAMIL LETTER MA..TAMIL LETTER HA - {0x0BBE, 0x0BBF, prCM, gcMc}, // [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I - {0x0BC0, 0x0BC0, prCM, gcMn}, // TAMIL VOWEL SIGN II - {0x0BC1, 0x0BC2, prCM, gcMc}, // [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU - {0x0BC6, 0x0BC8, prCM, gcMc}, // [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI - {0x0BCA, 0x0BCC, prCM, gcMc}, // [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU - {0x0BCD, 0x0BCD, prCM, gcMn}, // TAMIL SIGN VIRAMA - {0x0BD0, 0x0BD0, prAL, gcLo}, // TAMIL OM - {0x0BD7, 0x0BD7, prCM, gcMc}, // TAMIL AU LENGTH MARK - {0x0BE6, 0x0BEF, prNU, gcNd}, // [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE - {0x0BF0, 0x0BF2, prAL, gcNo}, // [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND - {0x0BF3, 0x0BF8, prAL, gcSo}, // [6] TAMIL DAY SIGN..TAMIL AS ABOVE SIGN - {0x0BF9, 0x0BF9, prPR, gcSc}, // TAMIL RUPEE SIGN - {0x0BFA, 0x0BFA, prAL, gcSo}, // TAMIL NUMBER SIGN - {0x0C00, 0x0C00, prCM, gcMn}, // TELUGU SIGN COMBINING CANDRABINDU ABOVE - {0x0C01, 0x0C03, prCM, gcMc}, // [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA - {0x0C04, 0x0C04, prCM, gcMn}, // TELUGU SIGN COMBINING ANUSVARA ABOVE - {0x0C05, 0x0C0C, prAL, gcLo}, // [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L - {0x0C0E, 0x0C10, prAL, gcLo}, // [3] TELUGU LETTER E..TELUGU LETTER AI - {0x0C12, 0x0C28, prAL, gcLo}, // [23] TELUGU LETTER O..TELUGU LETTER NA - {0x0C2A, 0x0C39, prAL, gcLo}, // [16] TELUGU LETTER PA..TELUGU LETTER HA - {0x0C3C, 0x0C3C, prCM, gcMn}, // TELUGU SIGN NUKTA - {0x0C3D, 0x0C3D, prAL, gcLo}, // TELUGU SIGN AVAGRAHA - {0x0C3E, 0x0C40, prCM, gcMn}, // [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II - {0x0C41, 0x0C44, prCM, gcMc}, // [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR - {0x0C46, 0x0C48, prCM, gcMn}, // [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI - {0x0C4A, 0x0C4D, prCM, gcMn}, // [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA - {0x0C55, 0x0C56, prCM, gcMn}, // [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK - {0x0C58, 0x0C5A, prAL, gcLo}, // [3] TELUGU LETTER TSA..TELUGU LETTER RRRA - {0x0C5D, 0x0C5D, prAL, gcLo}, // TELUGU LETTER NAKAARA POLLU - {0x0C60, 0x0C61, prAL, gcLo}, // [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL - {0x0C62, 0x0C63, prCM, gcMn}, // [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL - {0x0C66, 0x0C6F, prNU, gcNd}, // [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE - {0x0C77, 0x0C77, prBB, gcPo}, // TELUGU SIGN SIDDHAM - {0x0C78, 0x0C7E, prAL, gcNo}, // [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR - {0x0C7F, 0x0C7F, prAL, gcSo}, // TELUGU SIGN TUUMU - {0x0C80, 0x0C80, prAL, gcLo}, // KANNADA SIGN SPACING CANDRABINDU - {0x0C81, 0x0C81, prCM, gcMn}, // KANNADA SIGN CANDRABINDU - {0x0C82, 0x0C83, prCM, gcMc}, // [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA - {0x0C84, 0x0C84, prBB, gcPo}, // KANNADA SIGN SIDDHAM - {0x0C85, 0x0C8C, prAL, gcLo}, // [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L - {0x0C8E, 0x0C90, prAL, gcLo}, // [3] KANNADA LETTER E..KANNADA LETTER AI - {0x0C92, 0x0CA8, prAL, gcLo}, // [23] KANNADA LETTER O..KANNADA LETTER NA - {0x0CAA, 0x0CB3, prAL, gcLo}, // [10] KANNADA LETTER PA..KANNADA LETTER LLA - {0x0CB5, 0x0CB9, prAL, gcLo}, // [5] KANNADA LETTER VA..KANNADA LETTER HA - {0x0CBC, 0x0CBC, prCM, gcMn}, // KANNADA SIGN NUKTA - {0x0CBD, 0x0CBD, prAL, gcLo}, // KANNADA SIGN AVAGRAHA - {0x0CBE, 0x0CBE, prCM, gcMc}, // KANNADA VOWEL SIGN AA - {0x0CBF, 0x0CBF, prCM, gcMn}, // KANNADA VOWEL SIGN I - {0x0CC0, 0x0CC4, prCM, gcMc}, // [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR - {0x0CC6, 0x0CC6, prCM, gcMn}, // KANNADA VOWEL SIGN E - {0x0CC7, 0x0CC8, prCM, gcMc}, // [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI - {0x0CCA, 0x0CCB, prCM, gcMc}, // [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO - {0x0CCC, 0x0CCD, prCM, gcMn}, // [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA - {0x0CD5, 0x0CD6, prCM, gcMc}, // [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK - {0x0CDD, 0x0CDE, prAL, gcLo}, // [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA - {0x0CE0, 0x0CE1, prAL, gcLo}, // [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL - {0x0CE2, 0x0CE3, prCM, gcMn}, // [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL - {0x0CE6, 0x0CEF, prNU, gcNd}, // [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE - {0x0CF1, 0x0CF2, prAL, gcLo}, // [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA - {0x0CF3, 0x0CF3, prCM, gcMc}, // KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT - {0x0D00, 0x0D01, prCM, gcMn}, // [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU - {0x0D02, 0x0D03, prCM, gcMc}, // [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA - {0x0D04, 0x0D0C, prAL, gcLo}, // [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L - {0x0D0E, 0x0D10, prAL, gcLo}, // [3] MALAYALAM LETTER E..MALAYALAM LETTER AI - {0x0D12, 0x0D3A, prAL, gcLo}, // [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA - {0x0D3B, 0x0D3C, prCM, gcMn}, // [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA - {0x0D3D, 0x0D3D, prAL, gcLo}, // MALAYALAM SIGN AVAGRAHA - {0x0D3E, 0x0D40, prCM, gcMc}, // [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II - {0x0D41, 0x0D44, prCM, gcMn}, // [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR - {0x0D46, 0x0D48, prCM, gcMc}, // [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI - {0x0D4A, 0x0D4C, prCM, gcMc}, // [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU - {0x0D4D, 0x0D4D, prCM, gcMn}, // MALAYALAM SIGN VIRAMA - {0x0D4E, 0x0D4E, prAL, gcLo}, // MALAYALAM LETTER DOT REPH - {0x0D4F, 0x0D4F, prAL, gcSo}, // MALAYALAM SIGN PARA - {0x0D54, 0x0D56, prAL, gcLo}, // [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL - {0x0D57, 0x0D57, prCM, gcMc}, // MALAYALAM AU LENGTH MARK - {0x0D58, 0x0D5E, prAL, gcNo}, // [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH - {0x0D5F, 0x0D61, prAL, gcLo}, // [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL - {0x0D62, 0x0D63, prCM, gcMn}, // [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL - {0x0D66, 0x0D6F, prNU, gcNd}, // [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE - {0x0D70, 0x0D78, prAL, gcNo}, // [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS - {0x0D79, 0x0D79, prPO, gcSo}, // MALAYALAM DATE MARK - {0x0D7A, 0x0D7F, prAL, gcLo}, // [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K - {0x0D81, 0x0D81, prCM, gcMn}, // SINHALA SIGN CANDRABINDU - {0x0D82, 0x0D83, prCM, gcMc}, // [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA - {0x0D85, 0x0D96, prAL, gcLo}, // [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA - {0x0D9A, 0x0DB1, prAL, gcLo}, // [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA - {0x0DB3, 0x0DBB, prAL, gcLo}, // [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA - {0x0DBD, 0x0DBD, prAL, gcLo}, // SINHALA LETTER DANTAJA LAYANNA - {0x0DC0, 0x0DC6, prAL, gcLo}, // [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA - {0x0DCA, 0x0DCA, prCM, gcMn}, // SINHALA SIGN AL-LAKUNA - {0x0DCF, 0x0DD1, prCM, gcMc}, // [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA - {0x0DD2, 0x0DD4, prCM, gcMn}, // [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA - {0x0DD6, 0x0DD6, prCM, gcMn}, // SINHALA VOWEL SIGN DIGA PAA-PILLA - {0x0DD8, 0x0DDF, prCM, gcMc}, // [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA - {0x0DE6, 0x0DEF, prNU, gcNd}, // [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE - {0x0DF2, 0x0DF3, prCM, gcMc}, // [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA - {0x0DF4, 0x0DF4, prAL, gcPo}, // SINHALA PUNCTUATION KUNDDALIYA - {0x0E01, 0x0E30, prSA, gcLo}, // [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A - {0x0E31, 0x0E31, prSA, gcMn}, // THAI CHARACTER MAI HAN-AKAT - {0x0E32, 0x0E33, prSA, gcLo}, // [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM - {0x0E34, 0x0E3A, prSA, gcMn}, // [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU - {0x0E3F, 0x0E3F, prPR, gcSc}, // THAI CURRENCY SYMBOL BAHT - {0x0E40, 0x0E45, prSA, gcLo}, // [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO - {0x0E46, 0x0E46, prSA, gcLm}, // THAI CHARACTER MAIYAMOK - {0x0E47, 0x0E4E, prSA, gcMn}, // [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN - {0x0E4F, 0x0E4F, prAL, gcPo}, // THAI CHARACTER FONGMAN - {0x0E50, 0x0E59, prNU, gcNd}, // [10] THAI DIGIT ZERO..THAI DIGIT NINE - {0x0E5A, 0x0E5B, prBA, gcPo}, // [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT - {0x0E81, 0x0E82, prSA, gcLo}, // [2] LAO LETTER KO..LAO LETTER KHO SUNG - {0x0E84, 0x0E84, prSA, gcLo}, // LAO LETTER KHO TAM - {0x0E86, 0x0E8A, prSA, gcLo}, // [5] LAO LETTER PALI GHA..LAO LETTER SO TAM - {0x0E8C, 0x0EA3, prSA, gcLo}, // [24] LAO LETTER PALI JHA..LAO LETTER LO LING - {0x0EA5, 0x0EA5, prSA, gcLo}, // LAO LETTER LO LOOT - {0x0EA7, 0x0EB0, prSA, gcLo}, // [10] LAO LETTER WO..LAO VOWEL SIGN A - {0x0EB1, 0x0EB1, prSA, gcMn}, // LAO VOWEL SIGN MAI KAN - {0x0EB2, 0x0EB3, prSA, gcLo}, // [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM - {0x0EB4, 0x0EBC, prSA, gcMn}, // [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO - {0x0EBD, 0x0EBD, prSA, gcLo}, // LAO SEMIVOWEL SIGN NYO - {0x0EC0, 0x0EC4, prSA, gcLo}, // [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI - {0x0EC6, 0x0EC6, prSA, gcLm}, // LAO KO LA - {0x0EC8, 0x0ECE, prSA, gcMn}, // [7] LAO TONE MAI EK..LAO YAMAKKAN - {0x0ED0, 0x0ED9, prNU, gcNd}, // [10] LAO DIGIT ZERO..LAO DIGIT NINE - {0x0EDC, 0x0EDF, prSA, gcLo}, // [4] LAO HO NO..LAO LETTER KHMU NYO - {0x0F00, 0x0F00, prAL, gcLo}, // TIBETAN SYLLABLE OM - {0x0F01, 0x0F03, prBB, gcSo}, // [3] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA - {0x0F04, 0x0F04, prBB, gcPo}, // TIBETAN MARK INITIAL YIG MGO MDUN MA - {0x0F05, 0x0F05, prAL, gcPo}, // TIBETAN MARK CLOSING YIG MGO SGAB MA - {0x0F06, 0x0F07, prBB, gcPo}, // [2] TIBETAN MARK CARET YIG MGO PHUR SHAD MA..TIBETAN MARK YIG MGO TSHEG SHAD MA - {0x0F08, 0x0F08, prGL, gcPo}, // TIBETAN MARK SBRUL SHAD - {0x0F09, 0x0F0A, prBB, gcPo}, // [2] TIBETAN MARK BSKUR YIG MGO..TIBETAN MARK BKA- SHOG YIG MGO - {0x0F0B, 0x0F0B, prBA, gcPo}, // TIBETAN MARK INTERSYLLABIC TSHEG - {0x0F0C, 0x0F0C, prGL, gcPo}, // TIBETAN MARK DELIMITER TSHEG BSTAR - {0x0F0D, 0x0F11, prEX, gcPo}, // [5] TIBETAN MARK SHAD..TIBETAN MARK RIN CHEN SPUNGS SHAD - {0x0F12, 0x0F12, prGL, gcPo}, // TIBETAN MARK RGYA GRAM SHAD - {0x0F13, 0x0F13, prAL, gcSo}, // TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN - {0x0F14, 0x0F14, prEX, gcPo}, // TIBETAN MARK GTER TSHEG - {0x0F15, 0x0F17, prAL, gcSo}, // [3] TIBETAN LOGOTYPE SIGN CHAD RTAGS..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS - {0x0F18, 0x0F19, prCM, gcMn}, // [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS - {0x0F1A, 0x0F1F, prAL, gcSo}, // [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG - {0x0F20, 0x0F29, prNU, gcNd}, // [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE - {0x0F2A, 0x0F33, prAL, gcNo}, // [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO - {0x0F34, 0x0F34, prBA, gcSo}, // TIBETAN MARK BSDUS RTAGS - {0x0F35, 0x0F35, prCM, gcMn}, // TIBETAN MARK NGAS BZUNG NYI ZLA - {0x0F36, 0x0F36, prAL, gcSo}, // TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN - {0x0F37, 0x0F37, prCM, gcMn}, // TIBETAN MARK NGAS BZUNG SGOR RTAGS - {0x0F38, 0x0F38, prAL, gcSo}, // TIBETAN MARK CHE MGO - {0x0F39, 0x0F39, prCM, gcMn}, // TIBETAN MARK TSA -PHRU - {0x0F3A, 0x0F3A, prOP, gcPs}, // TIBETAN MARK GUG RTAGS GYON - {0x0F3B, 0x0F3B, prCL, gcPe}, // TIBETAN MARK GUG RTAGS GYAS - {0x0F3C, 0x0F3C, prOP, gcPs}, // TIBETAN MARK ANG KHANG GYON - {0x0F3D, 0x0F3D, prCL, gcPe}, // TIBETAN MARK ANG KHANG GYAS - {0x0F3E, 0x0F3F, prCM, gcMc}, // [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES - {0x0F40, 0x0F47, prAL, gcLo}, // [8] TIBETAN LETTER KA..TIBETAN LETTER JA - {0x0F49, 0x0F6C, prAL, gcLo}, // [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA - {0x0F71, 0x0F7E, prCM, gcMn}, // [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO - {0x0F7F, 0x0F7F, prBA, gcMc}, // TIBETAN SIGN RNAM BCAD - {0x0F80, 0x0F84, prCM, gcMn}, // [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA - {0x0F85, 0x0F85, prBA, gcPo}, // TIBETAN MARK PALUTA - {0x0F86, 0x0F87, prCM, gcMn}, // [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS - {0x0F88, 0x0F8C, prAL, gcLo}, // [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN - {0x0F8D, 0x0F97, prCM, gcMn}, // [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA - {0x0F99, 0x0FBC, prCM, gcMn}, // [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA - {0x0FBE, 0x0FBF, prBA, gcSo}, // [2] TIBETAN KU RU KHA..TIBETAN KU RU KHA BZHI MIG CAN - {0x0FC0, 0x0FC5, prAL, gcSo}, // [6] TIBETAN CANTILLATION SIGN HEAVY BEAT..TIBETAN SYMBOL RDO RJE - {0x0FC6, 0x0FC6, prCM, gcMn}, // TIBETAN SYMBOL PADMA GDAN - {0x0FC7, 0x0FCC, prAL, gcSo}, // [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL - {0x0FCE, 0x0FCF, prAL, gcSo}, // [2] TIBETAN SIGN RDEL NAG RDEL DKAR..TIBETAN SIGN RDEL NAG GSUM - {0x0FD0, 0x0FD1, prBB, gcPo}, // [2] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK MNYAM YIG GI MGO RGYAN - {0x0FD2, 0x0FD2, prBA, gcPo}, // TIBETAN MARK NYIS TSHEG - {0x0FD3, 0x0FD3, prBB, gcPo}, // TIBETAN MARK INITIAL BRDA RNYING YIG MGO MDUN MA - {0x0FD4, 0x0FD4, prAL, gcPo}, // TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA - {0x0FD5, 0x0FD8, prAL, gcSo}, // [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS - {0x0FD9, 0x0FDA, prGL, gcPo}, // [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS - {0x1000, 0x102A, prSA, gcLo}, // [43] MYANMAR LETTER KA..MYANMAR LETTER AU - {0x102B, 0x102C, prSA, gcMc}, // [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA - {0x102D, 0x1030, prSA, gcMn}, // [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU - {0x1031, 0x1031, prSA, gcMc}, // MYANMAR VOWEL SIGN E - {0x1032, 0x1037, prSA, gcMn}, // [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW - {0x1038, 0x1038, prSA, gcMc}, // MYANMAR SIGN VISARGA - {0x1039, 0x103A, prSA, gcMn}, // [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT - {0x103B, 0x103C, prSA, gcMc}, // [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA - {0x103D, 0x103E, prSA, gcMn}, // [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA - {0x103F, 0x103F, prSA, gcLo}, // MYANMAR LETTER GREAT SA - {0x1040, 0x1049, prNU, gcNd}, // [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE - {0x104A, 0x104B, prBA, gcPo}, // [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION - {0x104C, 0x104F, prAL, gcPo}, // [4] MYANMAR SYMBOL LOCATIVE..MYANMAR SYMBOL GENITIVE - {0x1050, 0x1055, prSA, gcLo}, // [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL - {0x1056, 0x1057, prSA, gcMc}, // [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR - {0x1058, 0x1059, prSA, gcMn}, // [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL - {0x105A, 0x105D, prSA, gcLo}, // [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE - {0x105E, 0x1060, prSA, gcMn}, // [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA - {0x1061, 0x1061, prSA, gcLo}, // MYANMAR LETTER SGAW KAREN SHA - {0x1062, 0x1064, prSA, gcMc}, // [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO - {0x1065, 0x1066, prSA, gcLo}, // [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA - {0x1067, 0x106D, prSA, gcMc}, // [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5 - {0x106E, 0x1070, prSA, gcLo}, // [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA - {0x1071, 0x1074, prSA, gcMn}, // [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE - {0x1075, 0x1081, prSA, gcLo}, // [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA - {0x1082, 0x1082, prSA, gcMn}, // MYANMAR CONSONANT SIGN SHAN MEDIAL WA - {0x1083, 0x1084, prSA, gcMc}, // [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E - {0x1085, 0x1086, prSA, gcMn}, // [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y - {0x1087, 0x108C, prSA, gcMc}, // [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3 - {0x108D, 0x108D, prSA, gcMn}, // MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE - {0x108E, 0x108E, prSA, gcLo}, // MYANMAR LETTER RUMAI PALAUNG FA - {0x108F, 0x108F, prSA, gcMc}, // MYANMAR SIGN RUMAI PALAUNG TONE-5 - {0x1090, 0x1099, prNU, gcNd}, // [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE - {0x109A, 0x109C, prSA, gcMc}, // [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A - {0x109D, 0x109D, prSA, gcMn}, // MYANMAR VOWEL SIGN AITON AI - {0x109E, 0x109F, prSA, gcSo}, // [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION - {0x10A0, 0x10C5, prAL, gcLu}, // [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE - {0x10C7, 0x10C7, prAL, gcLu}, // GEORGIAN CAPITAL LETTER YN - {0x10CD, 0x10CD, prAL, gcLu}, // GEORGIAN CAPITAL LETTER AEN - {0x10D0, 0x10FA, prAL, gcLl}, // [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN - {0x10FB, 0x10FB, prAL, gcPo}, // GEORGIAN PARAGRAPH SEPARATOR - {0x10FC, 0x10FC, prAL, gcLm}, // MODIFIER LETTER GEORGIAN NAR - {0x10FD, 0x10FF, prAL, gcLl}, // [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN - {0x1100, 0x115F, prJL, gcLo}, // [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER - {0x1160, 0x11A7, prJV, gcLo}, // [72] HANGUL JUNGSEONG FILLER..HANGUL JUNGSEONG O-YAE - {0x11A8, 0x11FF, prJT, gcLo}, // [88] HANGUL JONGSEONG KIYEOK..HANGUL JONGSEONG SSANGNIEUN - {0x1200, 0x1248, prAL, gcLo}, // [73] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE QWA - {0x124A, 0x124D, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE - {0x1250, 0x1256, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO - {0x1258, 0x1258, prAL, gcLo}, // ETHIOPIC SYLLABLE QHWA - {0x125A, 0x125D, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE - {0x1260, 0x1288, prAL, gcLo}, // [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA - {0x128A, 0x128D, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE - {0x1290, 0x12B0, prAL, gcLo}, // [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA - {0x12B2, 0x12B5, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE - {0x12B8, 0x12BE, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO - {0x12C0, 0x12C0, prAL, gcLo}, // ETHIOPIC SYLLABLE KXWA - {0x12C2, 0x12C5, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE - {0x12C8, 0x12D6, prAL, gcLo}, // [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O - {0x12D8, 0x1310, prAL, gcLo}, // [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA - {0x1312, 0x1315, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE - {0x1318, 0x135A, prAL, gcLo}, // [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA - {0x135D, 0x135F, prCM, gcMn}, // [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK - {0x1360, 0x1360, prAL, gcPo}, // ETHIOPIC SECTION MARK - {0x1361, 0x1361, prBA, gcPo}, // ETHIOPIC WORDSPACE - {0x1362, 0x1368, prAL, gcPo}, // [7] ETHIOPIC FULL STOP..ETHIOPIC PARAGRAPH SEPARATOR - {0x1369, 0x137C, prAL, gcNo}, // [20] ETHIOPIC DIGIT ONE..ETHIOPIC NUMBER TEN THOUSAND - {0x1380, 0x138F, prAL, gcLo}, // [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE - {0x1390, 0x1399, prAL, gcSo}, // [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT - {0x13A0, 0x13F5, prAL, gcLu}, // [86] CHEROKEE LETTER A..CHEROKEE LETTER MV - {0x13F8, 0x13FD, prAL, gcLl}, // [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV - {0x1400, 0x1400, prBA, gcPd}, // CANADIAN SYLLABICS HYPHEN - {0x1401, 0x166C, prAL, gcLo}, // [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA - {0x166D, 0x166D, prAL, gcSo}, // CANADIAN SYLLABICS CHI SIGN - {0x166E, 0x166E, prAL, gcPo}, // CANADIAN SYLLABICS FULL STOP - {0x166F, 0x167F, prAL, gcLo}, // [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W - {0x1680, 0x1680, prBA, gcZs}, // OGHAM SPACE MARK - {0x1681, 0x169A, prAL, gcLo}, // [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH - {0x169B, 0x169B, prOP, gcPs}, // OGHAM FEATHER MARK - {0x169C, 0x169C, prCL, gcPe}, // OGHAM REVERSED FEATHER MARK - {0x16A0, 0x16EA, prAL, gcLo}, // [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X - {0x16EB, 0x16ED, prBA, gcPo}, // [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION - {0x16EE, 0x16F0, prAL, gcNl}, // [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL - {0x16F1, 0x16F8, prAL, gcLo}, // [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC - {0x1700, 0x1711, prAL, gcLo}, // [18] TAGALOG LETTER A..TAGALOG LETTER HA - {0x1712, 0x1714, prCM, gcMn}, // [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA - {0x1715, 0x1715, prCM, gcMc}, // TAGALOG SIGN PAMUDPOD - {0x171F, 0x171F, prAL, gcLo}, // TAGALOG LETTER ARCHAIC RA - {0x1720, 0x1731, prAL, gcLo}, // [18] HANUNOO LETTER A..HANUNOO LETTER HA - {0x1732, 0x1733, prCM, gcMn}, // [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U - {0x1734, 0x1734, prCM, gcMc}, // HANUNOO SIGN PAMUDPOD - {0x1735, 0x1736, prBA, gcPo}, // [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION - {0x1740, 0x1751, prAL, gcLo}, // [18] BUHID LETTER A..BUHID LETTER HA - {0x1752, 0x1753, prCM, gcMn}, // [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U - {0x1760, 0x176C, prAL, gcLo}, // [13] TAGBANWA LETTER A..TAGBANWA LETTER YA - {0x176E, 0x1770, prAL, gcLo}, // [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA - {0x1772, 0x1773, prCM, gcMn}, // [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U - {0x1780, 0x17B3, prSA, gcLo}, // [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU - {0x17B4, 0x17B5, prSA, gcMn}, // [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA - {0x17B6, 0x17B6, prSA, gcMc}, // KHMER VOWEL SIGN AA - {0x17B7, 0x17BD, prSA, gcMn}, // [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA - {0x17BE, 0x17C5, prSA, gcMc}, // [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU - {0x17C6, 0x17C6, prSA, gcMn}, // KHMER SIGN NIKAHIT - {0x17C7, 0x17C8, prSA, gcMc}, // [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU - {0x17C9, 0x17D3, prSA, gcMn}, // [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT - {0x17D4, 0x17D5, prBA, gcPo}, // [2] KHMER SIGN KHAN..KHMER SIGN BARIYOOSAN - {0x17D6, 0x17D6, prNS, gcPo}, // KHMER SIGN CAMNUC PII KUUH - {0x17D7, 0x17D7, prSA, gcLm}, // KHMER SIGN LEK TOO - {0x17D8, 0x17D8, prBA, gcPo}, // KHMER SIGN BEYYAL - {0x17D9, 0x17D9, prAL, gcPo}, // KHMER SIGN PHNAEK MUAN - {0x17DA, 0x17DA, prBA, gcPo}, // KHMER SIGN KOOMUUT - {0x17DB, 0x17DB, prPR, gcSc}, // KHMER CURRENCY SYMBOL RIEL - {0x17DC, 0x17DC, prSA, gcLo}, // KHMER SIGN AVAKRAHASANYA - {0x17DD, 0x17DD, prSA, gcMn}, // KHMER SIGN ATTHACAN - {0x17E0, 0x17E9, prNU, gcNd}, // [10] KHMER DIGIT ZERO..KHMER DIGIT NINE - {0x17F0, 0x17F9, prAL, gcNo}, // [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON - {0x1800, 0x1801, prAL, gcPo}, // [2] MONGOLIAN BIRGA..MONGOLIAN ELLIPSIS - {0x1802, 0x1803, prEX, gcPo}, // [2] MONGOLIAN COMMA..MONGOLIAN FULL STOP - {0x1804, 0x1805, prBA, gcPo}, // [2] MONGOLIAN COLON..MONGOLIAN FOUR DOTS - {0x1806, 0x1806, prBB, gcPd}, // MONGOLIAN TODO SOFT HYPHEN - {0x1807, 0x1807, prAL, gcPo}, // MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER - {0x1808, 0x1809, prEX, gcPo}, // [2] MONGOLIAN MANCHU COMMA..MONGOLIAN MANCHU FULL STOP - {0x180A, 0x180A, prAL, gcPo}, // MONGOLIAN NIRUGU - {0x180B, 0x180D, prCM, gcMn}, // [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE - {0x180E, 0x180E, prGL, gcCf}, // MONGOLIAN VOWEL SEPARATOR - {0x180F, 0x180F, prCM, gcMn}, // MONGOLIAN FREE VARIATION SELECTOR FOUR - {0x1810, 0x1819, prNU, gcNd}, // [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE - {0x1820, 0x1842, prAL, gcLo}, // [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI - {0x1843, 0x1843, prAL, gcLm}, // MONGOLIAN LETTER TODO LONG VOWEL SIGN - {0x1844, 0x1878, prAL, gcLo}, // [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS - {0x1880, 0x1884, prAL, gcLo}, // [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA - {0x1885, 0x1886, prCM, gcMn}, // [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA - {0x1887, 0x18A8, prAL, gcLo}, // [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA - {0x18A9, 0x18A9, prCM, gcMn}, // MONGOLIAN LETTER ALI GALI DAGALGA - {0x18AA, 0x18AA, prAL, gcLo}, // MONGOLIAN LETTER MANCHU ALI GALI LHA - {0x18B0, 0x18F5, prAL, gcLo}, // [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S - {0x1900, 0x191E, prAL, gcLo}, // [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA - {0x1920, 0x1922, prCM, gcMn}, // [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U - {0x1923, 0x1926, prCM, gcMc}, // [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU - {0x1927, 0x1928, prCM, gcMn}, // [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O - {0x1929, 0x192B, prCM, gcMc}, // [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA - {0x1930, 0x1931, prCM, gcMc}, // [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA - {0x1932, 0x1932, prCM, gcMn}, // LIMBU SMALL LETTER ANUSVARA - {0x1933, 0x1938, prCM, gcMc}, // [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA - {0x1939, 0x193B, prCM, gcMn}, // [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I - {0x1940, 0x1940, prAL, gcSo}, // LIMBU SIGN LOO - {0x1944, 0x1945, prEX, gcPo}, // [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK - {0x1946, 0x194F, prNU, gcNd}, // [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE - {0x1950, 0x196D, prSA, gcLo}, // [30] TAI LE LETTER KA..TAI LE LETTER AI - {0x1970, 0x1974, prSA, gcLo}, // [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6 - {0x1980, 0x19AB, prSA, gcLo}, // [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA - {0x19B0, 0x19C9, prSA, gcLo}, // [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2 - {0x19D0, 0x19D9, prNU, gcNd}, // [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE - {0x19DA, 0x19DA, prSA, gcNo}, // NEW TAI LUE THAM DIGIT ONE - {0x19DE, 0x19DF, prSA, gcSo}, // [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV - {0x19E0, 0x19FF, prAL, gcSo}, // [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC - {0x1A00, 0x1A16, prAL, gcLo}, // [23] BUGINESE LETTER KA..BUGINESE LETTER HA - {0x1A17, 0x1A18, prCM, gcMn}, // [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U - {0x1A19, 0x1A1A, prCM, gcMc}, // [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O - {0x1A1B, 0x1A1B, prCM, gcMn}, // BUGINESE VOWEL SIGN AE - {0x1A1E, 0x1A1F, prAL, gcPo}, // [2] BUGINESE PALLAWA..BUGINESE END OF SECTION - {0x1A20, 0x1A54, prSA, gcLo}, // [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA - {0x1A55, 0x1A55, prSA, gcMc}, // TAI THAM CONSONANT SIGN MEDIAL RA - {0x1A56, 0x1A56, prSA, gcMn}, // TAI THAM CONSONANT SIGN MEDIAL LA - {0x1A57, 0x1A57, prSA, gcMc}, // TAI THAM CONSONANT SIGN LA TANG LAI - {0x1A58, 0x1A5E, prSA, gcMn}, // [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA - {0x1A60, 0x1A60, prSA, gcMn}, // TAI THAM SIGN SAKOT - {0x1A61, 0x1A61, prSA, gcMc}, // TAI THAM VOWEL SIGN A - {0x1A62, 0x1A62, prSA, gcMn}, // TAI THAM VOWEL SIGN MAI SAT - {0x1A63, 0x1A64, prSA, gcMc}, // [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA - {0x1A65, 0x1A6C, prSA, gcMn}, // [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW - {0x1A6D, 0x1A72, prSA, gcMc}, // [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI - {0x1A73, 0x1A7C, prSA, gcMn}, // [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN - {0x1A7F, 0x1A7F, prCM, gcMn}, // TAI THAM COMBINING CRYPTOGRAMMIC DOT - {0x1A80, 0x1A89, prNU, gcNd}, // [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE - {0x1A90, 0x1A99, prNU, gcNd}, // [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE - {0x1AA0, 0x1AA6, prSA, gcPo}, // [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA - {0x1AA7, 0x1AA7, prSA, gcLm}, // TAI THAM SIGN MAI YAMOK - {0x1AA8, 0x1AAD, prSA, gcPo}, // [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG - {0x1AB0, 0x1ABD, prCM, gcMn}, // [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW - {0x1ABE, 0x1ABE, prCM, gcMe}, // COMBINING PARENTHESES OVERLAY - {0x1ABF, 0x1ACE, prCM, gcMn}, // [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T - {0x1B00, 0x1B03, prCM, gcMn}, // [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG - {0x1B04, 0x1B04, prCM, gcMc}, // BALINESE SIGN BISAH - {0x1B05, 0x1B33, prAL, gcLo}, // [47] BALINESE LETTER AKARA..BALINESE LETTER HA - {0x1B34, 0x1B34, prCM, gcMn}, // BALINESE SIGN REREKAN - {0x1B35, 0x1B35, prCM, gcMc}, // BALINESE VOWEL SIGN TEDUNG - {0x1B36, 0x1B3A, prCM, gcMn}, // [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA - {0x1B3B, 0x1B3B, prCM, gcMc}, // BALINESE VOWEL SIGN RA REPA TEDUNG - {0x1B3C, 0x1B3C, prCM, gcMn}, // BALINESE VOWEL SIGN LA LENGA - {0x1B3D, 0x1B41, prCM, gcMc}, // [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG - {0x1B42, 0x1B42, prCM, gcMn}, // BALINESE VOWEL SIGN PEPET - {0x1B43, 0x1B44, prCM, gcMc}, // [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG - {0x1B45, 0x1B4C, prAL, gcLo}, // [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA - {0x1B50, 0x1B59, prNU, gcNd}, // [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE - {0x1B5A, 0x1B5B, prBA, gcPo}, // [2] BALINESE PANTI..BALINESE PAMADA - {0x1B5C, 0x1B5C, prAL, gcPo}, // BALINESE WINDU - {0x1B5D, 0x1B60, prBA, gcPo}, // [4] BALINESE CARIK PAMUNGKAH..BALINESE PAMENENG - {0x1B61, 0x1B6A, prAL, gcSo}, // [10] BALINESE MUSICAL SYMBOL DONG..BALINESE MUSICAL SYMBOL DANG GEDE - {0x1B6B, 0x1B73, prCM, gcMn}, // [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG - {0x1B74, 0x1B7C, prAL, gcSo}, // [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING - {0x1B7D, 0x1B7E, prBA, gcPo}, // [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG - {0x1B80, 0x1B81, prCM, gcMn}, // [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR - {0x1B82, 0x1B82, prCM, gcMc}, // SUNDANESE SIGN PANGWISAD - {0x1B83, 0x1BA0, prAL, gcLo}, // [30] SUNDANESE LETTER A..SUNDANESE LETTER HA - {0x1BA1, 0x1BA1, prCM, gcMc}, // SUNDANESE CONSONANT SIGN PAMINGKAL - {0x1BA2, 0x1BA5, prCM, gcMn}, // [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU - {0x1BA6, 0x1BA7, prCM, gcMc}, // [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG - {0x1BA8, 0x1BA9, prCM, gcMn}, // [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG - {0x1BAA, 0x1BAA, prCM, gcMc}, // SUNDANESE SIGN PAMAAEH - {0x1BAB, 0x1BAD, prCM, gcMn}, // [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA - {0x1BAE, 0x1BAF, prAL, gcLo}, // [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA - {0x1BB0, 0x1BB9, prNU, gcNd}, // [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE - {0x1BBA, 0x1BBF, prAL, gcLo}, // [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M - {0x1BC0, 0x1BE5, prAL, gcLo}, // [38] BATAK LETTER A..BATAK LETTER U - {0x1BE6, 0x1BE6, prCM, gcMn}, // BATAK SIGN TOMPI - {0x1BE7, 0x1BE7, prCM, gcMc}, // BATAK VOWEL SIGN E - {0x1BE8, 0x1BE9, prCM, gcMn}, // [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE - {0x1BEA, 0x1BEC, prCM, gcMc}, // [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O - {0x1BED, 0x1BED, prCM, gcMn}, // BATAK VOWEL SIGN KARO O - {0x1BEE, 0x1BEE, prCM, gcMc}, // BATAK VOWEL SIGN U - {0x1BEF, 0x1BF1, prCM, gcMn}, // [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H - {0x1BF2, 0x1BF3, prCM, gcMc}, // [2] BATAK PANGOLAT..BATAK PANONGONAN - {0x1BFC, 0x1BFF, prAL, gcPo}, // [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT - {0x1C00, 0x1C23, prAL, gcLo}, // [36] LEPCHA LETTER KA..LEPCHA LETTER A - {0x1C24, 0x1C2B, prCM, gcMc}, // [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU - {0x1C2C, 0x1C33, prCM, gcMn}, // [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T - {0x1C34, 0x1C35, prCM, gcMc}, // [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG - {0x1C36, 0x1C37, prCM, gcMn}, // [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA - {0x1C3B, 0x1C3F, prBA, gcPo}, // [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK - {0x1C40, 0x1C49, prNU, gcNd}, // [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE - {0x1C4D, 0x1C4F, prAL, gcLo}, // [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA - {0x1C50, 0x1C59, prNU, gcNd}, // [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE - {0x1C5A, 0x1C77, prAL, gcLo}, // [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH - {0x1C78, 0x1C7D, prAL, gcLm}, // [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD - {0x1C7E, 0x1C7F, prBA, gcPo}, // [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD - {0x1C80, 0x1C88, prAL, gcLl}, // [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK - {0x1C90, 0x1CBA, prAL, gcLu}, // [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN - {0x1CBD, 0x1CBF, prAL, gcLu}, // [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN - {0x1CC0, 0x1CC7, prAL, gcPo}, // [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA - {0x1CD0, 0x1CD2, prCM, gcMn}, // [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA - {0x1CD3, 0x1CD3, prAL, gcPo}, // VEDIC SIGN NIHSHVASA - {0x1CD4, 0x1CE0, prCM, gcMn}, // [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA - {0x1CE1, 0x1CE1, prCM, gcMc}, // VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA - {0x1CE2, 0x1CE8, prCM, gcMn}, // [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL - {0x1CE9, 0x1CEC, prAL, gcLo}, // [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL - {0x1CED, 0x1CED, prCM, gcMn}, // VEDIC SIGN TIRYAK - {0x1CEE, 0x1CF3, prAL, gcLo}, // [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA - {0x1CF4, 0x1CF4, prCM, gcMn}, // VEDIC TONE CANDRA ABOVE - {0x1CF5, 0x1CF6, prAL, gcLo}, // [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA - {0x1CF7, 0x1CF7, prCM, gcMc}, // VEDIC SIGN ATIKRAMA - {0x1CF8, 0x1CF9, prCM, gcMn}, // [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE - {0x1CFA, 0x1CFA, prAL, gcLo}, // VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA - {0x1D00, 0x1D2B, prAL, gcLl}, // [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL - {0x1D2C, 0x1D6A, prAL, gcLm}, // [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI - {0x1D6B, 0x1D77, prAL, gcLl}, // [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G - {0x1D78, 0x1D78, prAL, gcLm}, // MODIFIER LETTER CYRILLIC EN - {0x1D79, 0x1D7F, prAL, gcLl}, // [7] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER UPSILON WITH STROKE - {0x1D80, 0x1D9A, prAL, gcLl}, // [27] LATIN SMALL LETTER B WITH PALATAL HOOK..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK - {0x1D9B, 0x1DBF, prAL, gcLm}, // [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA - {0x1DC0, 0x1DCC, prCM, gcMn}, // [13] COMBINING DOTTED GRAVE ACCENT..COMBINING MACRON-BREVE - {0x1DCD, 0x1DCD, prGL, gcMn}, // COMBINING DOUBLE CIRCUMFLEX ABOVE - {0x1DCE, 0x1DFB, prCM, gcMn}, // [46] COMBINING OGONEK ABOVE..COMBINING DELETION MARK - {0x1DFC, 0x1DFC, prGL, gcMn}, // COMBINING DOUBLE INVERTED BREVE BELOW - {0x1DFD, 0x1DFF, prCM, gcMn}, // [3] COMBINING ALMOST EQUAL TO BELOW..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW - {0x1E00, 0x1EFF, prAL, gcLC}, // [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP - {0x1F00, 0x1F15, prAL, gcLC}, // [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA - {0x1F18, 0x1F1D, prAL, gcLu}, // [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA - {0x1F20, 0x1F45, prAL, gcLC}, // [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA - {0x1F48, 0x1F4D, prAL, gcLu}, // [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA - {0x1F50, 0x1F57, prAL, gcLl}, // [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI - {0x1F59, 0x1F59, prAL, gcLu}, // GREEK CAPITAL LETTER UPSILON WITH DASIA - {0x1F5B, 0x1F5B, prAL, gcLu}, // GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA - {0x1F5D, 0x1F5D, prAL, gcLu}, // GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA - {0x1F5F, 0x1F7D, prAL, gcLC}, // [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA - {0x1F80, 0x1FB4, prAL, gcLC}, // [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI - {0x1FB6, 0x1FBC, prAL, gcLC}, // [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI - {0x1FBD, 0x1FBD, prAL, gcSk}, // GREEK KORONIS - {0x1FBE, 0x1FBE, prAL, gcLl}, // GREEK PROSGEGRAMMENI - {0x1FBF, 0x1FC1, prAL, gcSk}, // [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI - {0x1FC2, 0x1FC4, prAL, gcLl}, // [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI - {0x1FC6, 0x1FCC, prAL, gcLC}, // [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI - {0x1FCD, 0x1FCF, prAL, gcSk}, // [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI - {0x1FD0, 0x1FD3, prAL, gcLl}, // [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA - {0x1FD6, 0x1FDB, prAL, gcLC}, // [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA - {0x1FDD, 0x1FDF, prAL, gcSk}, // [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI - {0x1FE0, 0x1FEC, prAL, gcLC}, // [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA - {0x1FED, 0x1FEF, prAL, gcSk}, // [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA - {0x1FF2, 0x1FF4, prAL, gcLl}, // [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI - {0x1FF6, 0x1FFC, prAL, gcLC}, // [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI - {0x1FFD, 0x1FFD, prBB, gcSk}, // GREEK OXIA - {0x1FFE, 0x1FFE, prAL, gcSk}, // GREEK DASIA - {0x2000, 0x2006, prBA, gcZs}, // [7] EN QUAD..SIX-PER-EM SPACE - {0x2007, 0x2007, prGL, gcZs}, // FIGURE SPACE - {0x2008, 0x200A, prBA, gcZs}, // [3] PUNCTUATION SPACE..HAIR SPACE - {0x200B, 0x200B, prZW, gcCf}, // ZERO WIDTH SPACE - {0x200C, 0x200C, prCM, gcCf}, // ZERO WIDTH NON-JOINER - {0x200D, 0x200D, prZWJ, gcCf}, // ZERO WIDTH JOINER - {0x200E, 0x200F, prCM, gcCf}, // [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK - {0x2010, 0x2010, prBA, gcPd}, // HYPHEN - {0x2011, 0x2011, prGL, gcPd}, // NON-BREAKING HYPHEN - {0x2012, 0x2013, prBA, gcPd}, // [2] FIGURE DASH..EN DASH - {0x2014, 0x2014, prB2, gcPd}, // EM DASH - {0x2015, 0x2015, prAI, gcPd}, // HORIZONTAL BAR - {0x2016, 0x2016, prAI, gcPo}, // DOUBLE VERTICAL LINE - {0x2017, 0x2017, prAL, gcPo}, // DOUBLE LOW LINE - {0x2018, 0x2018, prQU, gcPi}, // LEFT SINGLE QUOTATION MARK - {0x2019, 0x2019, prQU, gcPf}, // RIGHT SINGLE QUOTATION MARK - {0x201A, 0x201A, prOP, gcPs}, // SINGLE LOW-9 QUOTATION MARK - {0x201B, 0x201C, prQU, gcPi}, // [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK - {0x201D, 0x201D, prQU, gcPf}, // RIGHT DOUBLE QUOTATION MARK - {0x201E, 0x201E, prOP, gcPs}, // DOUBLE LOW-9 QUOTATION MARK - {0x201F, 0x201F, prQU, gcPi}, // DOUBLE HIGH-REVERSED-9 QUOTATION MARK - {0x2020, 0x2021, prAI, gcPo}, // [2] DAGGER..DOUBLE DAGGER - {0x2022, 0x2023, prAL, gcPo}, // [2] BULLET..TRIANGULAR BULLET - {0x2024, 0x2026, prIN, gcPo}, // [3] ONE DOT LEADER..HORIZONTAL ELLIPSIS - {0x2027, 0x2027, prBA, gcPo}, // HYPHENATION POINT - {0x2028, 0x2028, prBK, gcZl}, // LINE SEPARATOR - {0x2029, 0x2029, prBK, gcZp}, // PARAGRAPH SEPARATOR - {0x202A, 0x202E, prCM, gcCf}, // [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE - {0x202F, 0x202F, prGL, gcZs}, // NARROW NO-BREAK SPACE - {0x2030, 0x2037, prPO, gcPo}, // [8] PER MILLE SIGN..REVERSED TRIPLE PRIME - {0x2038, 0x2038, prAL, gcPo}, // CARET - {0x2039, 0x2039, prQU, gcPi}, // SINGLE LEFT-POINTING ANGLE QUOTATION MARK - {0x203A, 0x203A, prQU, gcPf}, // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK - {0x203B, 0x203B, prAI, gcPo}, // REFERENCE MARK - {0x203C, 0x203D, prNS, gcPo}, // [2] DOUBLE EXCLAMATION MARK..INTERROBANG - {0x203E, 0x203E, prAL, gcPo}, // OVERLINE - {0x203F, 0x2040, prAL, gcPc}, // [2] UNDERTIE..CHARACTER TIE - {0x2041, 0x2043, prAL, gcPo}, // [3] CARET INSERTION POINT..HYPHEN BULLET - {0x2044, 0x2044, prIS, gcSm}, // FRACTION SLASH - {0x2045, 0x2045, prOP, gcPs}, // LEFT SQUARE BRACKET WITH QUILL - {0x2046, 0x2046, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH QUILL - {0x2047, 0x2049, prNS, gcPo}, // [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK - {0x204A, 0x2051, prAL, gcPo}, // [8] TIRONIAN SIGN ET..TWO ASTERISKS ALIGNED VERTICALLY - {0x2052, 0x2052, prAL, gcSm}, // COMMERCIAL MINUS SIGN - {0x2053, 0x2053, prAL, gcPo}, // SWUNG DASH - {0x2054, 0x2054, prAL, gcPc}, // INVERTED UNDERTIE - {0x2055, 0x2055, prAL, gcPo}, // FLOWER PUNCTUATION MARK - {0x2056, 0x2056, prBA, gcPo}, // THREE DOT PUNCTUATION - {0x2057, 0x2057, prPO, gcPo}, // QUADRUPLE PRIME - {0x2058, 0x205B, prBA, gcPo}, // [4] FOUR DOT PUNCTUATION..FOUR DOT MARK - {0x205C, 0x205C, prAL, gcPo}, // DOTTED CROSS - {0x205D, 0x205E, prBA, gcPo}, // [2] TRICOLON..VERTICAL FOUR DOTS - {0x205F, 0x205F, prBA, gcZs}, // MEDIUM MATHEMATICAL SPACE - {0x2060, 0x2060, prWJ, gcCf}, // WORD JOINER - {0x2061, 0x2064, prAL, gcCf}, // [4] FUNCTION APPLICATION..INVISIBLE PLUS - {0x2066, 0x206F, prCM, gcCf}, // [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES - {0x2070, 0x2070, prAL, gcNo}, // SUPERSCRIPT ZERO - {0x2071, 0x2071, prAL, gcLm}, // SUPERSCRIPT LATIN SMALL LETTER I - {0x2074, 0x2074, prAI, gcNo}, // SUPERSCRIPT FOUR - {0x2075, 0x2079, prAL, gcNo}, // [5] SUPERSCRIPT FIVE..SUPERSCRIPT NINE - {0x207A, 0x207C, prAL, gcSm}, // [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN - {0x207D, 0x207D, prOP, gcPs}, // SUPERSCRIPT LEFT PARENTHESIS - {0x207E, 0x207E, prCL, gcPe}, // SUPERSCRIPT RIGHT PARENTHESIS - {0x207F, 0x207F, prAI, gcLm}, // SUPERSCRIPT LATIN SMALL LETTER N - {0x2080, 0x2080, prAL, gcNo}, // SUBSCRIPT ZERO - {0x2081, 0x2084, prAI, gcNo}, // [4] SUBSCRIPT ONE..SUBSCRIPT FOUR - {0x2085, 0x2089, prAL, gcNo}, // [5] SUBSCRIPT FIVE..SUBSCRIPT NINE - {0x208A, 0x208C, prAL, gcSm}, // [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN - {0x208D, 0x208D, prOP, gcPs}, // SUBSCRIPT LEFT PARENTHESIS - {0x208E, 0x208E, prCL, gcPe}, // SUBSCRIPT RIGHT PARENTHESIS - {0x2090, 0x209C, prAL, gcLm}, // [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T - {0x20A0, 0x20A6, prPR, gcSc}, // [7] EURO-CURRENCY SIGN..NAIRA SIGN - {0x20A7, 0x20A7, prPO, gcSc}, // PESETA SIGN - {0x20A8, 0x20B5, prPR, gcSc}, // [14] RUPEE SIGN..CEDI SIGN - {0x20B6, 0x20B6, prPO, gcSc}, // LIVRE TOURNOIS SIGN - {0x20B7, 0x20BA, prPR, gcSc}, // [4] SPESMILO SIGN..TURKISH LIRA SIGN - {0x20BB, 0x20BB, prPO, gcSc}, // NORDIC MARK SIGN - {0x20BC, 0x20BD, prPR, gcSc}, // [2] MANAT SIGN..RUBLE SIGN - {0x20BE, 0x20BE, prPO, gcSc}, // LARI SIGN - {0x20BF, 0x20BF, prPR, gcSc}, // BITCOIN SIGN - {0x20C0, 0x20C0, prPO, gcSc}, // SOM SIGN - {0x20C1, 0x20CF, prPR, gcCn}, // [15] .. - {0x20D0, 0x20DC, prCM, gcMn}, // [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE - {0x20DD, 0x20E0, prCM, gcMe}, // [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH - {0x20E1, 0x20E1, prCM, gcMn}, // COMBINING LEFT RIGHT ARROW ABOVE - {0x20E2, 0x20E4, prCM, gcMe}, // [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE - {0x20E5, 0x20F0, prCM, gcMn}, // [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE - {0x2100, 0x2101, prAL, gcSo}, // [2] ACCOUNT OF..ADDRESSED TO THE SUBJECT - {0x2102, 0x2102, prAL, gcLu}, // DOUBLE-STRUCK CAPITAL C - {0x2103, 0x2103, prPO, gcSo}, // DEGREE CELSIUS - {0x2104, 0x2104, prAL, gcSo}, // CENTRE LINE SYMBOL - {0x2105, 0x2105, prAI, gcSo}, // CARE OF - {0x2106, 0x2106, prAL, gcSo}, // CADA UNA - {0x2107, 0x2107, prAL, gcLu}, // EULER CONSTANT - {0x2108, 0x2108, prAL, gcSo}, // SCRUPLE - {0x2109, 0x2109, prPO, gcSo}, // DEGREE FAHRENHEIT - {0x210A, 0x2112, prAL, gcLC}, // [9] SCRIPT SMALL G..SCRIPT CAPITAL L - {0x2113, 0x2113, prAI, gcLl}, // SCRIPT SMALL L - {0x2114, 0x2114, prAL, gcSo}, // L B BAR SYMBOL - {0x2115, 0x2115, prAL, gcLu}, // DOUBLE-STRUCK CAPITAL N - {0x2116, 0x2116, prPR, gcSo}, // NUMERO SIGN - {0x2117, 0x2117, prAL, gcSo}, // SOUND RECORDING COPYRIGHT - {0x2118, 0x2118, prAL, gcSm}, // SCRIPT CAPITAL P - {0x2119, 0x211D, prAL, gcLu}, // [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R - {0x211E, 0x2120, prAL, gcSo}, // [3] PRESCRIPTION TAKE..SERVICE MARK - {0x2121, 0x2122, prAI, gcSo}, // [2] TELEPHONE SIGN..TRADE MARK SIGN - {0x2123, 0x2123, prAL, gcSo}, // VERSICLE - {0x2124, 0x2124, prAL, gcLu}, // DOUBLE-STRUCK CAPITAL Z - {0x2125, 0x2125, prAL, gcSo}, // OUNCE SIGN - {0x2126, 0x2126, prAL, gcLu}, // OHM SIGN - {0x2127, 0x2127, prAL, gcSo}, // INVERTED OHM SIGN - {0x2128, 0x2128, prAL, gcLu}, // BLACK-LETTER CAPITAL Z - {0x2129, 0x2129, prAL, gcSo}, // TURNED GREEK SMALL LETTER IOTA - {0x212A, 0x212A, prAL, gcLu}, // KELVIN SIGN - {0x212B, 0x212B, prAI, gcLu}, // ANGSTROM SIGN - {0x212C, 0x212D, prAL, gcLu}, // [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C - {0x212E, 0x212E, prAL, gcSo}, // ESTIMATED SYMBOL - {0x212F, 0x2134, prAL, gcLC}, // [6] SCRIPT SMALL E..SCRIPT SMALL O - {0x2135, 0x2138, prAL, gcLo}, // [4] ALEF SYMBOL..DALET SYMBOL - {0x2139, 0x2139, prAL, gcLl}, // INFORMATION SOURCE - {0x213A, 0x213B, prAL, gcSo}, // [2] ROTATED CAPITAL Q..FACSIMILE SIGN - {0x213C, 0x213F, prAL, gcLC}, // [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI - {0x2140, 0x2144, prAL, gcSm}, // [5] DOUBLE-STRUCK N-ARY SUMMATION..TURNED SANS-SERIF CAPITAL Y - {0x2145, 0x2149, prAL, gcLC}, // [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J - {0x214A, 0x214A, prAL, gcSo}, // PROPERTY LINE - {0x214B, 0x214B, prAL, gcSm}, // TURNED AMPERSAND - {0x214C, 0x214D, prAL, gcSo}, // [2] PER SIGN..AKTIESELSKAB - {0x214E, 0x214E, prAL, gcLl}, // TURNED SMALL F - {0x214F, 0x214F, prAL, gcSo}, // SYMBOL FOR SAMARITAN SOURCE - {0x2150, 0x2153, prAL, gcNo}, // [4] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE THIRD - {0x2154, 0x2155, prAI, gcNo}, // [2] VULGAR FRACTION TWO THIRDS..VULGAR FRACTION ONE FIFTH - {0x2156, 0x215A, prAL, gcNo}, // [5] VULGAR FRACTION TWO FIFTHS..VULGAR FRACTION FIVE SIXTHS - {0x215B, 0x215B, prAI, gcNo}, // VULGAR FRACTION ONE EIGHTH - {0x215C, 0x215D, prAL, gcNo}, // [2] VULGAR FRACTION THREE EIGHTHS..VULGAR FRACTION FIVE EIGHTHS - {0x215E, 0x215E, prAI, gcNo}, // VULGAR FRACTION SEVEN EIGHTHS - {0x215F, 0x215F, prAL, gcNo}, // FRACTION NUMERATOR ONE - {0x2160, 0x216B, prAI, gcNl}, // [12] ROMAN NUMERAL ONE..ROMAN NUMERAL TWELVE - {0x216C, 0x216F, prAL, gcNl}, // [4] ROMAN NUMERAL FIFTY..ROMAN NUMERAL ONE THOUSAND - {0x2170, 0x2179, prAI, gcNl}, // [10] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL TEN - {0x217A, 0x2182, prAL, gcNl}, // [9] SMALL ROMAN NUMERAL ELEVEN..ROMAN NUMERAL TEN THOUSAND - {0x2183, 0x2184, prAL, gcLC}, // [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C - {0x2185, 0x2188, prAL, gcNl}, // [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND - {0x2189, 0x2189, prAI, gcNo}, // VULGAR FRACTION ZERO THIRDS - {0x218A, 0x218B, prAL, gcSo}, // [2] TURNED DIGIT TWO..TURNED DIGIT THREE - {0x2190, 0x2194, prAI, gcSm}, // [5] LEFTWARDS ARROW..LEFT RIGHT ARROW - {0x2195, 0x2199, prAI, gcSo}, // [5] UP DOWN ARROW..SOUTH WEST ARROW - {0x219A, 0x219B, prAL, gcSm}, // [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE - {0x219C, 0x219F, prAL, gcSo}, // [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW - {0x21A0, 0x21A0, prAL, gcSm}, // RIGHTWARDS TWO HEADED ARROW - {0x21A1, 0x21A2, prAL, gcSo}, // [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL - {0x21A3, 0x21A3, prAL, gcSm}, // RIGHTWARDS ARROW WITH TAIL - {0x21A4, 0x21A5, prAL, gcSo}, // [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR - {0x21A6, 0x21A6, prAL, gcSm}, // RIGHTWARDS ARROW FROM BAR - {0x21A7, 0x21AD, prAL, gcSo}, // [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW - {0x21AE, 0x21AE, prAL, gcSm}, // LEFT RIGHT ARROW WITH STROKE - {0x21AF, 0x21CD, prAL, gcSo}, // [31] DOWNWARDS ZIGZAG ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE - {0x21CE, 0x21CF, prAL, gcSm}, // [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE - {0x21D0, 0x21D1, prAL, gcSo}, // [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW - {0x21D2, 0x21D2, prAI, gcSm}, // RIGHTWARDS DOUBLE ARROW - {0x21D3, 0x21D3, prAL, gcSo}, // DOWNWARDS DOUBLE ARROW - {0x21D4, 0x21D4, prAI, gcSm}, // LEFT RIGHT DOUBLE ARROW - {0x21D5, 0x21F3, prAL, gcSo}, // [31] UP DOWN DOUBLE ARROW..UP DOWN WHITE ARROW - {0x21F4, 0x21FF, prAL, gcSm}, // [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW - {0x2200, 0x2200, prAI, gcSm}, // FOR ALL - {0x2201, 0x2201, prAL, gcSm}, // COMPLEMENT - {0x2202, 0x2203, prAI, gcSm}, // [2] PARTIAL DIFFERENTIAL..THERE EXISTS - {0x2204, 0x2206, prAL, gcSm}, // [3] THERE DOES NOT EXIST..INCREMENT - {0x2207, 0x2208, prAI, gcSm}, // [2] NABLA..ELEMENT OF - {0x2209, 0x220A, prAL, gcSm}, // [2] NOT AN ELEMENT OF..SMALL ELEMENT OF - {0x220B, 0x220B, prAI, gcSm}, // CONTAINS AS MEMBER - {0x220C, 0x220E, prAL, gcSm}, // [3] DOES NOT CONTAIN AS MEMBER..END OF PROOF - {0x220F, 0x220F, prAI, gcSm}, // N-ARY PRODUCT - {0x2210, 0x2210, prAL, gcSm}, // N-ARY COPRODUCT - {0x2211, 0x2211, prAI, gcSm}, // N-ARY SUMMATION - {0x2212, 0x2213, prPR, gcSm}, // [2] MINUS SIGN..MINUS-OR-PLUS SIGN - {0x2214, 0x2214, prAL, gcSm}, // DOT PLUS - {0x2215, 0x2215, prAI, gcSm}, // DIVISION SLASH - {0x2216, 0x2219, prAL, gcSm}, // [4] SET MINUS..BULLET OPERATOR - {0x221A, 0x221A, prAI, gcSm}, // SQUARE ROOT - {0x221B, 0x221C, prAL, gcSm}, // [2] CUBE ROOT..FOURTH ROOT - {0x221D, 0x2220, prAI, gcSm}, // [4] PROPORTIONAL TO..ANGLE - {0x2221, 0x2222, prAL, gcSm}, // [2] MEASURED ANGLE..SPHERICAL ANGLE - {0x2223, 0x2223, prAI, gcSm}, // DIVIDES - {0x2224, 0x2224, prAL, gcSm}, // DOES NOT DIVIDE - {0x2225, 0x2225, prAI, gcSm}, // PARALLEL TO - {0x2226, 0x2226, prAL, gcSm}, // NOT PARALLEL TO - {0x2227, 0x222C, prAI, gcSm}, // [6] LOGICAL AND..DOUBLE INTEGRAL - {0x222D, 0x222D, prAL, gcSm}, // TRIPLE INTEGRAL - {0x222E, 0x222E, prAI, gcSm}, // CONTOUR INTEGRAL - {0x222F, 0x2233, prAL, gcSm}, // [5] SURFACE INTEGRAL..ANTICLOCKWISE CONTOUR INTEGRAL - {0x2234, 0x2237, prAI, gcSm}, // [4] THEREFORE..PROPORTION - {0x2238, 0x223B, prAL, gcSm}, // [4] DOT MINUS..HOMOTHETIC - {0x223C, 0x223D, prAI, gcSm}, // [2] TILDE OPERATOR..REVERSED TILDE - {0x223E, 0x2247, prAL, gcSm}, // [10] INVERTED LAZY S..NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO - {0x2248, 0x2248, prAI, gcSm}, // ALMOST EQUAL TO - {0x2249, 0x224B, prAL, gcSm}, // [3] NOT ALMOST EQUAL TO..TRIPLE TILDE - {0x224C, 0x224C, prAI, gcSm}, // ALL EQUAL TO - {0x224D, 0x2251, prAL, gcSm}, // [5] EQUIVALENT TO..GEOMETRICALLY EQUAL TO - {0x2252, 0x2252, prAI, gcSm}, // APPROXIMATELY EQUAL TO OR THE IMAGE OF - {0x2253, 0x225F, prAL, gcSm}, // [13] IMAGE OF OR APPROXIMATELY EQUAL TO..QUESTIONED EQUAL TO - {0x2260, 0x2261, prAI, gcSm}, // [2] NOT EQUAL TO..IDENTICAL TO - {0x2262, 0x2263, prAL, gcSm}, // [2] NOT IDENTICAL TO..STRICTLY EQUIVALENT TO - {0x2264, 0x2267, prAI, gcSm}, // [4] LESS-THAN OR EQUAL TO..GREATER-THAN OVER EQUAL TO - {0x2268, 0x2269, prAL, gcSm}, // [2] LESS-THAN BUT NOT EQUAL TO..GREATER-THAN BUT NOT EQUAL TO - {0x226A, 0x226B, prAI, gcSm}, // [2] MUCH LESS-THAN..MUCH GREATER-THAN - {0x226C, 0x226D, prAL, gcSm}, // [2] BETWEEN..NOT EQUIVALENT TO - {0x226E, 0x226F, prAI, gcSm}, // [2] NOT LESS-THAN..NOT GREATER-THAN - {0x2270, 0x2281, prAL, gcSm}, // [18] NEITHER LESS-THAN NOR EQUAL TO..DOES NOT SUCCEED - {0x2282, 0x2283, prAI, gcSm}, // [2] SUBSET OF..SUPERSET OF - {0x2284, 0x2285, prAL, gcSm}, // [2] NOT A SUBSET OF..NOT A SUPERSET OF - {0x2286, 0x2287, prAI, gcSm}, // [2] SUBSET OF OR EQUAL TO..SUPERSET OF OR EQUAL TO - {0x2288, 0x2294, prAL, gcSm}, // [13] NEITHER A SUBSET OF NOR EQUAL TO..SQUARE CUP - {0x2295, 0x2295, prAI, gcSm}, // CIRCLED PLUS - {0x2296, 0x2298, prAL, gcSm}, // [3] CIRCLED MINUS..CIRCLED DIVISION SLASH - {0x2299, 0x2299, prAI, gcSm}, // CIRCLED DOT OPERATOR - {0x229A, 0x22A4, prAL, gcSm}, // [11] CIRCLED RING OPERATOR..DOWN TACK - {0x22A5, 0x22A5, prAI, gcSm}, // UP TACK - {0x22A6, 0x22BE, prAL, gcSm}, // [25] ASSERTION..RIGHT ANGLE WITH ARC - {0x22BF, 0x22BF, prAI, gcSm}, // RIGHT TRIANGLE - {0x22C0, 0x22EE, prAL, gcSm}, // [47] N-ARY LOGICAL AND..VERTICAL ELLIPSIS - {0x22EF, 0x22EF, prIN, gcSm}, // MIDLINE HORIZONTAL ELLIPSIS - {0x22F0, 0x22FF, prAL, gcSm}, // [16] UP RIGHT DIAGONAL ELLIPSIS..Z NOTATION BAG MEMBERSHIP - {0x2300, 0x2307, prAL, gcSo}, // [8] DIAMETER SIGN..WAVY LINE - {0x2308, 0x2308, prOP, gcPs}, // LEFT CEILING - {0x2309, 0x2309, prCL, gcPe}, // RIGHT CEILING - {0x230A, 0x230A, prOP, gcPs}, // LEFT FLOOR - {0x230B, 0x230B, prCL, gcPe}, // RIGHT FLOOR - {0x230C, 0x2311, prAL, gcSo}, // [6] BOTTOM RIGHT CROP..SQUARE LOZENGE - {0x2312, 0x2312, prAI, gcSo}, // ARC - {0x2313, 0x2319, prAL, gcSo}, // [7] SEGMENT..TURNED NOT SIGN - {0x231A, 0x231B, prID, gcSo}, // [2] WATCH..HOURGLASS - {0x231C, 0x231F, prAL, gcSo}, // [4] TOP LEFT CORNER..BOTTOM RIGHT CORNER - {0x2320, 0x2321, prAL, gcSm}, // [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL - {0x2322, 0x2328, prAL, gcSo}, // [7] FROWN..KEYBOARD - {0x2329, 0x2329, prOP, gcPs}, // LEFT-POINTING ANGLE BRACKET - {0x232A, 0x232A, prCL, gcPe}, // RIGHT-POINTING ANGLE BRACKET - {0x232B, 0x237B, prAL, gcSo}, // [81] ERASE TO THE LEFT..NOT CHECK MARK - {0x237C, 0x237C, prAL, gcSm}, // RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW - {0x237D, 0x239A, prAL, gcSo}, // [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL - {0x239B, 0x23B3, prAL, gcSm}, // [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM - {0x23B4, 0x23DB, prAL, gcSo}, // [40] TOP SQUARE BRACKET..FUSE - {0x23DC, 0x23E1, prAL, gcSm}, // [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET - {0x23E2, 0x23EF, prAL, gcSo}, // [14] WHITE TRAPEZIUM..BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR - {0x23F0, 0x23F3, prID, gcSo}, // [4] ALARM CLOCK..HOURGLASS WITH FLOWING SAND - {0x23F4, 0x23FF, prAL, gcSo}, // [12] BLACK MEDIUM LEFT-POINTING TRIANGLE..OBSERVER EYE SYMBOL - {0x2400, 0x2426, prAL, gcSo}, // [39] SYMBOL FOR NULL..SYMBOL FOR SUBSTITUTE FORM TWO - {0x2440, 0x244A, prAL, gcSo}, // [11] OCR HOOK..OCR DOUBLE BACKSLASH - {0x2460, 0x249B, prAI, gcNo}, // [60] CIRCLED DIGIT ONE..NUMBER TWENTY FULL STOP - {0x249C, 0x24E9, prAI, gcSo}, // [78] PARENTHESIZED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z - {0x24EA, 0x24FE, prAI, gcNo}, // [21] CIRCLED DIGIT ZERO..DOUBLE CIRCLED NUMBER TEN - {0x24FF, 0x24FF, prAL, gcNo}, // NEGATIVE CIRCLED DIGIT ZERO - {0x2500, 0x254B, prAI, gcSo}, // [76] BOX DRAWINGS LIGHT HORIZONTAL..BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL - {0x254C, 0x254F, prAL, gcSo}, // [4] BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL..BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL - {0x2550, 0x2574, prAI, gcSo}, // [37] BOX DRAWINGS DOUBLE HORIZONTAL..BOX DRAWINGS LIGHT LEFT - {0x2575, 0x257F, prAL, gcSo}, // [11] BOX DRAWINGS LIGHT UP..BOX DRAWINGS HEAVY UP AND LIGHT DOWN - {0x2580, 0x258F, prAI, gcSo}, // [16] UPPER HALF BLOCK..LEFT ONE EIGHTH BLOCK - {0x2590, 0x2591, prAL, gcSo}, // [2] RIGHT HALF BLOCK..LIGHT SHADE - {0x2592, 0x2595, prAI, gcSo}, // [4] MEDIUM SHADE..RIGHT ONE EIGHTH BLOCK - {0x2596, 0x259F, prAL, gcSo}, // [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT - {0x25A0, 0x25A1, prAI, gcSo}, // [2] BLACK SQUARE..WHITE SQUARE - {0x25A2, 0x25A2, prAL, gcSo}, // WHITE SQUARE WITH ROUNDED CORNERS - {0x25A3, 0x25A9, prAI, gcSo}, // [7] WHITE SQUARE CONTAINING BLACK SMALL SQUARE..SQUARE WITH DIAGONAL CROSSHATCH FILL - {0x25AA, 0x25B1, prAL, gcSo}, // [8] BLACK SMALL SQUARE..WHITE PARALLELOGRAM - {0x25B2, 0x25B3, prAI, gcSo}, // [2] BLACK UP-POINTING TRIANGLE..WHITE UP-POINTING TRIANGLE - {0x25B4, 0x25B5, prAL, gcSo}, // [2] BLACK UP-POINTING SMALL TRIANGLE..WHITE UP-POINTING SMALL TRIANGLE - {0x25B6, 0x25B6, prAI, gcSo}, // BLACK RIGHT-POINTING TRIANGLE - {0x25B7, 0x25B7, prAI, gcSm}, // WHITE RIGHT-POINTING TRIANGLE - {0x25B8, 0x25BB, prAL, gcSo}, // [4] BLACK RIGHT-POINTING SMALL TRIANGLE..WHITE RIGHT-POINTING POINTER - {0x25BC, 0x25BD, prAI, gcSo}, // [2] BLACK DOWN-POINTING TRIANGLE..WHITE DOWN-POINTING TRIANGLE - {0x25BE, 0x25BF, prAL, gcSo}, // [2] BLACK DOWN-POINTING SMALL TRIANGLE..WHITE DOWN-POINTING SMALL TRIANGLE - {0x25C0, 0x25C0, prAI, gcSo}, // BLACK LEFT-POINTING TRIANGLE - {0x25C1, 0x25C1, prAI, gcSm}, // WHITE LEFT-POINTING TRIANGLE - {0x25C2, 0x25C5, prAL, gcSo}, // [4] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE LEFT-POINTING POINTER - {0x25C6, 0x25C8, prAI, gcSo}, // [3] BLACK DIAMOND..WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND - {0x25C9, 0x25CA, prAL, gcSo}, // [2] FISHEYE..LOZENGE - {0x25CB, 0x25CB, prAI, gcSo}, // WHITE CIRCLE - {0x25CC, 0x25CD, prAL, gcSo}, // [2] DOTTED CIRCLE..CIRCLE WITH VERTICAL FILL - {0x25CE, 0x25D1, prAI, gcSo}, // [4] BULLSEYE..CIRCLE WITH RIGHT HALF BLACK - {0x25D2, 0x25E1, prAL, gcSo}, // [16] CIRCLE WITH LOWER HALF BLACK..LOWER HALF CIRCLE - {0x25E2, 0x25E5, prAI, gcSo}, // [4] BLACK LOWER RIGHT TRIANGLE..BLACK UPPER RIGHT TRIANGLE - {0x25E6, 0x25EE, prAL, gcSo}, // [9] WHITE BULLET..UP-POINTING TRIANGLE WITH RIGHT HALF BLACK - {0x25EF, 0x25EF, prAI, gcSo}, // LARGE CIRCLE - {0x25F0, 0x25F7, prAL, gcSo}, // [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT - {0x25F8, 0x25FF, prAL, gcSm}, // [8] UPPER LEFT TRIANGLE..LOWER RIGHT TRIANGLE - {0x2600, 0x2603, prID, gcSo}, // [4] BLACK SUN WITH RAYS..SNOWMAN - {0x2604, 0x2604, prAL, gcSo}, // COMET - {0x2605, 0x2606, prAI, gcSo}, // [2] BLACK STAR..WHITE STAR - {0x2607, 0x2608, prAL, gcSo}, // [2] LIGHTNING..THUNDERSTORM - {0x2609, 0x2609, prAI, gcSo}, // SUN - {0x260A, 0x260D, prAL, gcSo}, // [4] ASCENDING NODE..OPPOSITION - {0x260E, 0x260F, prAI, gcSo}, // [2] BLACK TELEPHONE..WHITE TELEPHONE - {0x2610, 0x2613, prAL, gcSo}, // [4] BALLOT BOX..SALTIRE - {0x2614, 0x2615, prID, gcSo}, // [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE - {0x2616, 0x2617, prAI, gcSo}, // [2] WHITE SHOGI PIECE..BLACK SHOGI PIECE - {0x2618, 0x2618, prID, gcSo}, // SHAMROCK - {0x2619, 0x2619, prAL, gcSo}, // REVERSED ROTATED FLORAL HEART BULLET - {0x261A, 0x261C, prID, gcSo}, // [3] BLACK LEFT POINTING INDEX..WHITE LEFT POINTING INDEX - {0x261D, 0x261D, prEB, gcSo}, // WHITE UP POINTING INDEX - {0x261E, 0x261F, prID, gcSo}, // [2] WHITE RIGHT POINTING INDEX..WHITE DOWN POINTING INDEX - {0x2620, 0x2638, prAL, gcSo}, // [25] SKULL AND CROSSBONES..WHEEL OF DHARMA - {0x2639, 0x263B, prID, gcSo}, // [3] WHITE FROWNING FACE..BLACK SMILING FACE - {0x263C, 0x263F, prAL, gcSo}, // [4] WHITE SUN WITH RAYS..MERCURY - {0x2640, 0x2640, prAI, gcSo}, // FEMALE SIGN - {0x2641, 0x2641, prAL, gcSo}, // EARTH - {0x2642, 0x2642, prAI, gcSo}, // MALE SIGN - {0x2643, 0x265F, prAL, gcSo}, // [29] JUPITER..BLACK CHESS PAWN - {0x2660, 0x2661, prAI, gcSo}, // [2] BLACK SPADE SUIT..WHITE HEART SUIT - {0x2662, 0x2662, prAL, gcSo}, // WHITE DIAMOND SUIT - {0x2663, 0x2665, prAI, gcSo}, // [3] BLACK CLUB SUIT..BLACK HEART SUIT - {0x2666, 0x2666, prAL, gcSo}, // BLACK DIAMOND SUIT - {0x2667, 0x2667, prAI, gcSo}, // WHITE CLUB SUIT - {0x2668, 0x2668, prID, gcSo}, // HOT SPRINGS - {0x2669, 0x266A, prAI, gcSo}, // [2] QUARTER NOTE..EIGHTH NOTE - {0x266B, 0x266B, prAL, gcSo}, // BEAMED EIGHTH NOTES - {0x266C, 0x266D, prAI, gcSo}, // [2] BEAMED SIXTEENTH NOTES..MUSIC FLAT SIGN - {0x266E, 0x266E, prAL, gcSo}, // MUSIC NATURAL SIGN - {0x266F, 0x266F, prAI, gcSm}, // MUSIC SHARP SIGN - {0x2670, 0x267E, prAL, gcSo}, // [15] WEST SYRIAC CROSS..PERMANENT PAPER SIGN - {0x267F, 0x267F, prID, gcSo}, // WHEELCHAIR SYMBOL - {0x2680, 0x269D, prAL, gcSo}, // [30] DIE FACE-1..OUTLINED WHITE STAR - {0x269E, 0x269F, prAI, gcSo}, // [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT - {0x26A0, 0x26BC, prAL, gcSo}, // [29] WARNING SIGN..SESQUIQUADRATE - {0x26BD, 0x26C8, prID, gcSo}, // [12] SOCCER BALL..THUNDER CLOUD AND RAIN - {0x26C9, 0x26CC, prAI, gcSo}, // [4] TURNED WHITE SHOGI PIECE..CROSSING LANES - {0x26CD, 0x26CD, prID, gcSo}, // DISABLED CAR - {0x26CE, 0x26CE, prAL, gcSo}, // OPHIUCHUS - {0x26CF, 0x26D1, prID, gcSo}, // [3] PICK..HELMET WITH WHITE CROSS - {0x26D2, 0x26D2, prAI, gcSo}, // CIRCLED CROSSING LANES - {0x26D3, 0x26D4, prID, gcSo}, // [2] CHAINS..NO ENTRY - {0x26D5, 0x26D7, prAI, gcSo}, // [3] ALTERNATE ONE-WAY LEFT WAY TRAFFIC..WHITE TWO-WAY LEFT WAY TRAFFIC - {0x26D8, 0x26D9, prID, gcSo}, // [2] BLACK LEFT LANE MERGE..WHITE LEFT LANE MERGE - {0x26DA, 0x26DB, prAI, gcSo}, // [2] DRIVE SLOW SIGN..HEAVY WHITE DOWN-POINTING TRIANGLE - {0x26DC, 0x26DC, prID, gcSo}, // LEFT CLOSED ENTRY - {0x26DD, 0x26DE, prAI, gcSo}, // [2] SQUARED SALTIRE..FALLING DIAGONAL IN WHITE CIRCLE IN BLACK SQUARE - {0x26DF, 0x26E1, prID, gcSo}, // [3] BLACK TRUCK..RESTRICTED LEFT ENTRY-2 - {0x26E2, 0x26E2, prAL, gcSo}, // ASTRONOMICAL SYMBOL FOR URANUS - {0x26E3, 0x26E3, prAI, gcSo}, // HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE - {0x26E4, 0x26E7, prAL, gcSo}, // [4] PENTAGRAM..INVERTED PENTAGRAM - {0x26E8, 0x26E9, prAI, gcSo}, // [2] BLACK CROSS ON SHIELD..SHINTO SHRINE - {0x26EA, 0x26EA, prID, gcSo}, // CHURCH - {0x26EB, 0x26F0, prAI, gcSo}, // [6] CASTLE..MOUNTAIN - {0x26F1, 0x26F5, prID, gcSo}, // [5] UMBRELLA ON GROUND..SAILBOAT - {0x26F6, 0x26F6, prAI, gcSo}, // SQUARE FOUR CORNERS - {0x26F7, 0x26F8, prID, gcSo}, // [2] SKIER..ICE SKATE - {0x26F9, 0x26F9, prEB, gcSo}, // PERSON WITH BALL - {0x26FA, 0x26FA, prID, gcSo}, // TENT - {0x26FB, 0x26FC, prAI, gcSo}, // [2] JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL - {0x26FD, 0x26FF, prID, gcSo}, // [3] FUEL PUMP..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE - {0x2700, 0x2704, prID, gcSo}, // [5] BLACK SAFETY SCISSORS..WHITE SCISSORS - {0x2705, 0x2707, prAL, gcSo}, // [3] WHITE HEAVY CHECK MARK..TAPE DRIVE - {0x2708, 0x2709, prID, gcSo}, // [2] AIRPLANE..ENVELOPE - {0x270A, 0x270D, prEB, gcSo}, // [4] RAISED FIST..WRITING HAND - {0x270E, 0x2756, prAL, gcSo}, // [73] LOWER RIGHT PENCIL..BLACK DIAMOND MINUS WHITE X - {0x2757, 0x2757, prAI, gcSo}, // HEAVY EXCLAMATION MARK SYMBOL - {0x2758, 0x275A, prAL, gcSo}, // [3] LIGHT VERTICAL BAR..HEAVY VERTICAL BAR - {0x275B, 0x2760, prQU, gcSo}, // [6] HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT..HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT - {0x2761, 0x2761, prAL, gcSo}, // CURVED STEM PARAGRAPH SIGN ORNAMENT - {0x2762, 0x2763, prEX, gcSo}, // [2] HEAVY EXCLAMATION MARK ORNAMENT..HEAVY HEART EXCLAMATION MARK ORNAMENT - {0x2764, 0x2764, prID, gcSo}, // HEAVY BLACK HEART - {0x2765, 0x2767, prAL, gcSo}, // [3] ROTATED HEAVY BLACK HEART BULLET..ROTATED FLORAL HEART BULLET - {0x2768, 0x2768, prOP, gcPs}, // MEDIUM LEFT PARENTHESIS ORNAMENT - {0x2769, 0x2769, prCL, gcPe}, // MEDIUM RIGHT PARENTHESIS ORNAMENT - {0x276A, 0x276A, prOP, gcPs}, // MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT - {0x276B, 0x276B, prCL, gcPe}, // MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT - {0x276C, 0x276C, prOP, gcPs}, // MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x276D, 0x276D, prCL, gcPe}, // MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x276E, 0x276E, prOP, gcPs}, // HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x276F, 0x276F, prCL, gcPe}, // HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x2770, 0x2770, prOP, gcPs}, // HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x2771, 0x2771, prCL, gcPe}, // HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x2772, 0x2772, prOP, gcPs}, // LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT - {0x2773, 0x2773, prCL, gcPe}, // LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT - {0x2774, 0x2774, prOP, gcPs}, // MEDIUM LEFT CURLY BRACKET ORNAMENT - {0x2775, 0x2775, prCL, gcPe}, // MEDIUM RIGHT CURLY BRACKET ORNAMENT - {0x2776, 0x2793, prAI, gcNo}, // [30] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN - {0x2794, 0x27BF, prAL, gcSo}, // [44] HEAVY WIDE-HEADED RIGHTWARDS ARROW..DOUBLE CURLY LOOP - {0x27C0, 0x27C4, prAL, gcSm}, // [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET - {0x27C5, 0x27C5, prOP, gcPs}, // LEFT S-SHAPED BAG DELIMITER - {0x27C6, 0x27C6, prCL, gcPe}, // RIGHT S-SHAPED BAG DELIMITER - {0x27C7, 0x27E5, prAL, gcSm}, // [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK - {0x27E6, 0x27E6, prOP, gcPs}, // MATHEMATICAL LEFT WHITE SQUARE BRACKET - {0x27E7, 0x27E7, prCL, gcPe}, // MATHEMATICAL RIGHT WHITE SQUARE BRACKET - {0x27E8, 0x27E8, prOP, gcPs}, // MATHEMATICAL LEFT ANGLE BRACKET - {0x27E9, 0x27E9, prCL, gcPe}, // MATHEMATICAL RIGHT ANGLE BRACKET - {0x27EA, 0x27EA, prOP, gcPs}, // MATHEMATICAL LEFT DOUBLE ANGLE BRACKET - {0x27EB, 0x27EB, prCL, gcPe}, // MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET - {0x27EC, 0x27EC, prOP, gcPs}, // MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET - {0x27ED, 0x27ED, prCL, gcPe}, // MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET - {0x27EE, 0x27EE, prOP, gcPs}, // MATHEMATICAL LEFT FLATTENED PARENTHESIS - {0x27EF, 0x27EF, prCL, gcPe}, // MATHEMATICAL RIGHT FLATTENED PARENTHESIS - {0x27F0, 0x27FF, prAL, gcSm}, // [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW - {0x2800, 0x28FF, prAL, gcSo}, // [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678 - {0x2900, 0x297F, prAL, gcSm}, // [128] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..DOWN FISH TAIL - {0x2980, 0x2982, prAL, gcSm}, // [3] TRIPLE VERTICAL BAR DELIMITER..Z NOTATION TYPE COLON - {0x2983, 0x2983, prOP, gcPs}, // LEFT WHITE CURLY BRACKET - {0x2984, 0x2984, prCL, gcPe}, // RIGHT WHITE CURLY BRACKET - {0x2985, 0x2985, prOP, gcPs}, // LEFT WHITE PARENTHESIS - {0x2986, 0x2986, prCL, gcPe}, // RIGHT WHITE PARENTHESIS - {0x2987, 0x2987, prOP, gcPs}, // Z NOTATION LEFT IMAGE BRACKET - {0x2988, 0x2988, prCL, gcPe}, // Z NOTATION RIGHT IMAGE BRACKET - {0x2989, 0x2989, prOP, gcPs}, // Z NOTATION LEFT BINDING BRACKET - {0x298A, 0x298A, prCL, gcPe}, // Z NOTATION RIGHT BINDING BRACKET - {0x298B, 0x298B, prOP, gcPs}, // LEFT SQUARE BRACKET WITH UNDERBAR - {0x298C, 0x298C, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH UNDERBAR - {0x298D, 0x298D, prOP, gcPs}, // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x298E, 0x298E, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x298F, 0x298F, prOP, gcPs}, // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x2990, 0x2990, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x2991, 0x2991, prOP, gcPs}, // LEFT ANGLE BRACKET WITH DOT - {0x2992, 0x2992, prCL, gcPe}, // RIGHT ANGLE BRACKET WITH DOT - {0x2993, 0x2993, prOP, gcPs}, // LEFT ARC LESS-THAN BRACKET - {0x2994, 0x2994, prCL, gcPe}, // RIGHT ARC GREATER-THAN BRACKET - {0x2995, 0x2995, prOP, gcPs}, // DOUBLE LEFT ARC GREATER-THAN BRACKET - {0x2996, 0x2996, prCL, gcPe}, // DOUBLE RIGHT ARC LESS-THAN BRACKET - {0x2997, 0x2997, prOP, gcPs}, // LEFT BLACK TORTOISE SHELL BRACKET - {0x2998, 0x2998, prCL, gcPe}, // RIGHT BLACK TORTOISE SHELL BRACKET - {0x2999, 0x29D7, prAL, gcSm}, // [63] DOTTED FENCE..BLACK HOURGLASS - {0x29D8, 0x29D8, prOP, gcPs}, // LEFT WIGGLY FENCE - {0x29D9, 0x29D9, prCL, gcPe}, // RIGHT WIGGLY FENCE - {0x29DA, 0x29DA, prOP, gcPs}, // LEFT DOUBLE WIGGLY FENCE - {0x29DB, 0x29DB, prCL, gcPe}, // RIGHT DOUBLE WIGGLY FENCE - {0x29DC, 0x29FB, prAL, gcSm}, // [32] INCOMPLETE INFINITY..TRIPLE PLUS - {0x29FC, 0x29FC, prOP, gcPs}, // LEFT-POINTING CURVED ANGLE BRACKET - {0x29FD, 0x29FD, prCL, gcPe}, // RIGHT-POINTING CURVED ANGLE BRACKET - {0x29FE, 0x29FF, prAL, gcSm}, // [2] TINY..MINY - {0x2A00, 0x2AFF, prAL, gcSm}, // [256] N-ARY CIRCLED DOT OPERATOR..N-ARY WHITE VERTICAL BAR - {0x2B00, 0x2B2F, prAL, gcSo}, // [48] NORTH EAST WHITE ARROW..WHITE VERTICAL ELLIPSE - {0x2B30, 0x2B44, prAL, gcSm}, // [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET - {0x2B45, 0x2B46, prAL, gcSo}, // [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW - {0x2B47, 0x2B4C, prAL, gcSm}, // [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR - {0x2B4D, 0x2B54, prAL, gcSo}, // [8] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..WHITE RIGHT-POINTING PENTAGON - {0x2B55, 0x2B59, prAI, gcSo}, // [5] HEAVY LARGE CIRCLE..HEAVY CIRCLED SALTIRE - {0x2B5A, 0x2B73, prAL, gcSo}, // [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR - {0x2B76, 0x2B95, prAL, gcSo}, // [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW - {0x2B97, 0x2BFF, prAL, gcSo}, // [105] SYMBOL FOR TYPE A ELECTRONICS..HELLSCHREIBER PAUSE SYMBOL - {0x2C00, 0x2C5F, prAL, gcLC}, // [96] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI - {0x2C60, 0x2C7B, prAL, gcLC}, // [28] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN LETTER SMALL CAPITAL TURNED E - {0x2C7C, 0x2C7D, prAL, gcLm}, // [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V - {0x2C7E, 0x2C7F, prAL, gcLu}, // [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL - {0x2C80, 0x2CE4, prAL, gcLC}, // [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI - {0x2CE5, 0x2CEA, prAL, gcSo}, // [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA - {0x2CEB, 0x2CEE, prAL, gcLC}, // [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA - {0x2CEF, 0x2CF1, prCM, gcMn}, // [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS - {0x2CF2, 0x2CF3, prAL, gcLC}, // [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI - {0x2CF9, 0x2CF9, prEX, gcPo}, // COPTIC OLD NUBIAN FULL STOP - {0x2CFA, 0x2CFC, prBA, gcPo}, // [3] COPTIC OLD NUBIAN DIRECT QUESTION MARK..COPTIC OLD NUBIAN VERSE DIVIDER - {0x2CFD, 0x2CFD, prAL, gcNo}, // COPTIC FRACTION ONE HALF - {0x2CFE, 0x2CFE, prEX, gcPo}, // COPTIC FULL STOP - {0x2CFF, 0x2CFF, prBA, gcPo}, // COPTIC MORPHOLOGICAL DIVIDER - {0x2D00, 0x2D25, prAL, gcLl}, // [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE - {0x2D27, 0x2D27, prAL, gcLl}, // GEORGIAN SMALL LETTER YN - {0x2D2D, 0x2D2D, prAL, gcLl}, // GEORGIAN SMALL LETTER AEN - {0x2D30, 0x2D67, prAL, gcLo}, // [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO - {0x2D6F, 0x2D6F, prAL, gcLm}, // TIFINAGH MODIFIER LETTER LABIALIZATION MARK - {0x2D70, 0x2D70, prBA, gcPo}, // TIFINAGH SEPARATOR MARK - {0x2D7F, 0x2D7F, prCM, gcMn}, // TIFINAGH CONSONANT JOINER - {0x2D80, 0x2D96, prAL, gcLo}, // [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE - {0x2DA0, 0x2DA6, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO - {0x2DA8, 0x2DAE, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO - {0x2DB0, 0x2DB6, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO - {0x2DB8, 0x2DBE, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO - {0x2DC0, 0x2DC6, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO - {0x2DC8, 0x2DCE, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO - {0x2DD0, 0x2DD6, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO - {0x2DD8, 0x2DDE, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO - {0x2DE0, 0x2DFF, prCM, gcMn}, // [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS - {0x2E00, 0x2E01, prQU, gcPo}, // [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER - {0x2E02, 0x2E02, prQU, gcPi}, // LEFT SUBSTITUTION BRACKET - {0x2E03, 0x2E03, prQU, gcPf}, // RIGHT SUBSTITUTION BRACKET - {0x2E04, 0x2E04, prQU, gcPi}, // LEFT DOTTED SUBSTITUTION BRACKET - {0x2E05, 0x2E05, prQU, gcPf}, // RIGHT DOTTED SUBSTITUTION BRACKET - {0x2E06, 0x2E08, prQU, gcPo}, // [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER - {0x2E09, 0x2E09, prQU, gcPi}, // LEFT TRANSPOSITION BRACKET - {0x2E0A, 0x2E0A, prQU, gcPf}, // RIGHT TRANSPOSITION BRACKET - {0x2E0B, 0x2E0B, prQU, gcPo}, // RAISED SQUARE - {0x2E0C, 0x2E0C, prQU, gcPi}, // LEFT RAISED OMISSION BRACKET - {0x2E0D, 0x2E0D, prQU, gcPf}, // RIGHT RAISED OMISSION BRACKET - {0x2E0E, 0x2E15, prBA, gcPo}, // [8] EDITORIAL CORONIS..UPWARDS ANCORA - {0x2E16, 0x2E16, prAL, gcPo}, // DOTTED RIGHT-POINTING ANGLE - {0x2E17, 0x2E17, prBA, gcPd}, // DOUBLE OBLIQUE HYPHEN - {0x2E18, 0x2E18, prOP, gcPo}, // INVERTED INTERROBANG - {0x2E19, 0x2E19, prBA, gcPo}, // PALM BRANCH - {0x2E1A, 0x2E1A, prAL, gcPd}, // HYPHEN WITH DIAERESIS - {0x2E1B, 0x2E1B, prAL, gcPo}, // TILDE WITH RING ABOVE - {0x2E1C, 0x2E1C, prQU, gcPi}, // LEFT LOW PARAPHRASE BRACKET - {0x2E1D, 0x2E1D, prQU, gcPf}, // RIGHT LOW PARAPHRASE BRACKET - {0x2E1E, 0x2E1F, prAL, gcPo}, // [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW - {0x2E20, 0x2E20, prQU, gcPi}, // LEFT VERTICAL BAR WITH QUILL - {0x2E21, 0x2E21, prQU, gcPf}, // RIGHT VERTICAL BAR WITH QUILL - {0x2E22, 0x2E22, prOP, gcPs}, // TOP LEFT HALF BRACKET - {0x2E23, 0x2E23, prCL, gcPe}, // TOP RIGHT HALF BRACKET - {0x2E24, 0x2E24, prOP, gcPs}, // BOTTOM LEFT HALF BRACKET - {0x2E25, 0x2E25, prCL, gcPe}, // BOTTOM RIGHT HALF BRACKET - {0x2E26, 0x2E26, prOP, gcPs}, // LEFT SIDEWAYS U BRACKET - {0x2E27, 0x2E27, prCL, gcPe}, // RIGHT SIDEWAYS U BRACKET - {0x2E28, 0x2E28, prOP, gcPs}, // LEFT DOUBLE PARENTHESIS - {0x2E29, 0x2E29, prCL, gcPe}, // RIGHT DOUBLE PARENTHESIS - {0x2E2A, 0x2E2D, prBA, gcPo}, // [4] TWO DOTS OVER ONE DOT PUNCTUATION..FIVE DOT MARK - {0x2E2E, 0x2E2E, prEX, gcPo}, // REVERSED QUESTION MARK - {0x2E2F, 0x2E2F, prAL, gcLm}, // VERTICAL TILDE - {0x2E30, 0x2E31, prBA, gcPo}, // [2] RING POINT..WORD SEPARATOR MIDDLE DOT - {0x2E32, 0x2E32, prAL, gcPo}, // TURNED COMMA - {0x2E33, 0x2E34, prBA, gcPo}, // [2] RAISED DOT..RAISED COMMA - {0x2E35, 0x2E39, prAL, gcPo}, // [5] TURNED SEMICOLON..TOP HALF SECTION SIGN - {0x2E3A, 0x2E3B, prB2, gcPd}, // [2] TWO-EM DASH..THREE-EM DASH - {0x2E3C, 0x2E3E, prBA, gcPo}, // [3] STENOGRAPHIC FULL STOP..WIGGLY VERTICAL LINE - {0x2E3F, 0x2E3F, prAL, gcPo}, // CAPITULUM - {0x2E40, 0x2E40, prBA, gcPd}, // DOUBLE HYPHEN - {0x2E41, 0x2E41, prBA, gcPo}, // REVERSED COMMA - {0x2E42, 0x2E42, prOP, gcPs}, // DOUBLE LOW-REVERSED-9 QUOTATION MARK - {0x2E43, 0x2E4A, prBA, gcPo}, // [8] DASH WITH LEFT UPTURN..DOTTED SOLIDUS - {0x2E4B, 0x2E4B, prAL, gcPo}, // TRIPLE DAGGER - {0x2E4C, 0x2E4C, prBA, gcPo}, // MEDIEVAL COMMA - {0x2E4D, 0x2E4D, prAL, gcPo}, // PARAGRAPHUS MARK - {0x2E4E, 0x2E4F, prBA, gcPo}, // [2] PUNCTUS ELEVATUS MARK..CORNISH VERSE DIVIDER - {0x2E50, 0x2E51, prAL, gcSo}, // [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR - {0x2E52, 0x2E52, prAL, gcPo}, // TIRONIAN SIGN CAPITAL ET - {0x2E53, 0x2E54, prEX, gcPo}, // [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK - {0x2E55, 0x2E55, prOP, gcPs}, // LEFT SQUARE BRACKET WITH STROKE - {0x2E56, 0x2E56, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH STROKE - {0x2E57, 0x2E57, prOP, gcPs}, // LEFT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E58, 0x2E58, prCL, gcPe}, // RIGHT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E59, 0x2E59, prOP, gcPs}, // TOP HALF LEFT PARENTHESIS - {0x2E5A, 0x2E5A, prCL, gcPe}, // TOP HALF RIGHT PARENTHESIS - {0x2E5B, 0x2E5B, prOP, gcPs}, // BOTTOM HALF LEFT PARENTHESIS - {0x2E5C, 0x2E5C, prCL, gcPe}, // BOTTOM HALF RIGHT PARENTHESIS - {0x2E5D, 0x2E5D, prBA, gcPd}, // OBLIQUE HYPHEN - {0x2E80, 0x2E99, prID, gcSo}, // [26] CJK RADICAL REPEAT..CJK RADICAL RAP - {0x2E9B, 0x2EF3, prID, gcSo}, // [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE - {0x2F00, 0x2FD5, prID, gcSo}, // [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE - {0x2FF0, 0x2FFB, prID, gcSo}, // [12] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID - {0x3000, 0x3000, prBA, gcZs}, // IDEOGRAPHIC SPACE - {0x3001, 0x3002, prCL, gcPo}, // [2] IDEOGRAPHIC COMMA..IDEOGRAPHIC FULL STOP - {0x3003, 0x3003, prID, gcPo}, // DITTO MARK - {0x3004, 0x3004, prID, gcSo}, // JAPANESE INDUSTRIAL STANDARD SYMBOL - {0x3005, 0x3005, prNS, gcLm}, // IDEOGRAPHIC ITERATION MARK - {0x3006, 0x3006, prID, gcLo}, // IDEOGRAPHIC CLOSING MARK - {0x3007, 0x3007, prID, gcNl}, // IDEOGRAPHIC NUMBER ZERO - {0x3008, 0x3008, prOP, gcPs}, // LEFT ANGLE BRACKET - {0x3009, 0x3009, prCL, gcPe}, // RIGHT ANGLE BRACKET - {0x300A, 0x300A, prOP, gcPs}, // LEFT DOUBLE ANGLE BRACKET - {0x300B, 0x300B, prCL, gcPe}, // RIGHT DOUBLE ANGLE BRACKET - {0x300C, 0x300C, prOP, gcPs}, // LEFT CORNER BRACKET - {0x300D, 0x300D, prCL, gcPe}, // RIGHT CORNER BRACKET - {0x300E, 0x300E, prOP, gcPs}, // LEFT WHITE CORNER BRACKET - {0x300F, 0x300F, prCL, gcPe}, // RIGHT WHITE CORNER BRACKET - {0x3010, 0x3010, prOP, gcPs}, // LEFT BLACK LENTICULAR BRACKET - {0x3011, 0x3011, prCL, gcPe}, // RIGHT BLACK LENTICULAR BRACKET - {0x3012, 0x3013, prID, gcSo}, // [2] POSTAL MARK..GETA MARK - {0x3014, 0x3014, prOP, gcPs}, // LEFT TORTOISE SHELL BRACKET - {0x3015, 0x3015, prCL, gcPe}, // RIGHT TORTOISE SHELL BRACKET - {0x3016, 0x3016, prOP, gcPs}, // LEFT WHITE LENTICULAR BRACKET - {0x3017, 0x3017, prCL, gcPe}, // RIGHT WHITE LENTICULAR BRACKET - {0x3018, 0x3018, prOP, gcPs}, // LEFT WHITE TORTOISE SHELL BRACKET - {0x3019, 0x3019, prCL, gcPe}, // RIGHT WHITE TORTOISE SHELL BRACKET - {0x301A, 0x301A, prOP, gcPs}, // LEFT WHITE SQUARE BRACKET - {0x301B, 0x301B, prCL, gcPe}, // RIGHT WHITE SQUARE BRACKET - {0x301C, 0x301C, prNS, gcPd}, // WAVE DASH - {0x301D, 0x301D, prOP, gcPs}, // REVERSED DOUBLE PRIME QUOTATION MARK - {0x301E, 0x301F, prCL, gcPe}, // [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK - {0x3020, 0x3020, prID, gcSo}, // POSTAL MARK FACE - {0x3021, 0x3029, prID, gcNl}, // [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE - {0x302A, 0x302D, prCM, gcMn}, // [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK - {0x302E, 0x302F, prCM, gcMc}, // [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK - {0x3030, 0x3030, prID, gcPd}, // WAVY DASH - {0x3031, 0x3034, prID, gcLm}, // [4] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT WITH VOICED SOUND MARK UPPER HALF - {0x3035, 0x3035, prCM, gcLm}, // VERTICAL KANA REPEAT MARK LOWER HALF - {0x3036, 0x3037, prID, gcSo}, // [2] CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL - {0x3038, 0x303A, prID, gcNl}, // [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY - {0x303B, 0x303B, prNS, gcLm}, // VERTICAL IDEOGRAPHIC ITERATION MARK - {0x303C, 0x303C, prNS, gcLo}, // MASU MARK - {0x303D, 0x303D, prID, gcPo}, // PART ALTERNATION MARK - {0x303E, 0x303F, prID, gcSo}, // [2] IDEOGRAPHIC VARIATION INDICATOR..IDEOGRAPHIC HALF FILL SPACE - {0x3041, 0x3041, prCJ, gcLo}, // HIRAGANA LETTER SMALL A - {0x3042, 0x3042, prID, gcLo}, // HIRAGANA LETTER A - {0x3043, 0x3043, prCJ, gcLo}, // HIRAGANA LETTER SMALL I - {0x3044, 0x3044, prID, gcLo}, // HIRAGANA LETTER I - {0x3045, 0x3045, prCJ, gcLo}, // HIRAGANA LETTER SMALL U - {0x3046, 0x3046, prID, gcLo}, // HIRAGANA LETTER U - {0x3047, 0x3047, prCJ, gcLo}, // HIRAGANA LETTER SMALL E - {0x3048, 0x3048, prID, gcLo}, // HIRAGANA LETTER E - {0x3049, 0x3049, prCJ, gcLo}, // HIRAGANA LETTER SMALL O - {0x304A, 0x3062, prID, gcLo}, // [25] HIRAGANA LETTER O..HIRAGANA LETTER DI - {0x3063, 0x3063, prCJ, gcLo}, // HIRAGANA LETTER SMALL TU - {0x3064, 0x3082, prID, gcLo}, // [31] HIRAGANA LETTER TU..HIRAGANA LETTER MO - {0x3083, 0x3083, prCJ, gcLo}, // HIRAGANA LETTER SMALL YA - {0x3084, 0x3084, prID, gcLo}, // HIRAGANA LETTER YA - {0x3085, 0x3085, prCJ, gcLo}, // HIRAGANA LETTER SMALL YU - {0x3086, 0x3086, prID, gcLo}, // HIRAGANA LETTER YU - {0x3087, 0x3087, prCJ, gcLo}, // HIRAGANA LETTER SMALL YO - {0x3088, 0x308D, prID, gcLo}, // [6] HIRAGANA LETTER YO..HIRAGANA LETTER RO - {0x308E, 0x308E, prCJ, gcLo}, // HIRAGANA LETTER SMALL WA - {0x308F, 0x3094, prID, gcLo}, // [6] HIRAGANA LETTER WA..HIRAGANA LETTER VU - {0x3095, 0x3096, prCJ, gcLo}, // [2] HIRAGANA LETTER SMALL KA..HIRAGANA LETTER SMALL KE - {0x3099, 0x309A, prCM, gcMn}, // [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309B, 0x309C, prNS, gcSk}, // [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309D, 0x309E, prNS, gcLm}, // [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK - {0x309F, 0x309F, prID, gcLo}, // HIRAGANA DIGRAPH YORI - {0x30A0, 0x30A0, prNS, gcPd}, // KATAKANA-HIRAGANA DOUBLE HYPHEN - {0x30A1, 0x30A1, prCJ, gcLo}, // KATAKANA LETTER SMALL A - {0x30A2, 0x30A2, prID, gcLo}, // KATAKANA LETTER A - {0x30A3, 0x30A3, prCJ, gcLo}, // KATAKANA LETTER SMALL I - {0x30A4, 0x30A4, prID, gcLo}, // KATAKANA LETTER I - {0x30A5, 0x30A5, prCJ, gcLo}, // KATAKANA LETTER SMALL U - {0x30A6, 0x30A6, prID, gcLo}, // KATAKANA LETTER U - {0x30A7, 0x30A7, prCJ, gcLo}, // KATAKANA LETTER SMALL E - {0x30A8, 0x30A8, prID, gcLo}, // KATAKANA LETTER E - {0x30A9, 0x30A9, prCJ, gcLo}, // KATAKANA LETTER SMALL O - {0x30AA, 0x30C2, prID, gcLo}, // [25] KATAKANA LETTER O..KATAKANA LETTER DI - {0x30C3, 0x30C3, prCJ, gcLo}, // KATAKANA LETTER SMALL TU - {0x30C4, 0x30E2, prID, gcLo}, // [31] KATAKANA LETTER TU..KATAKANA LETTER MO - {0x30E3, 0x30E3, prCJ, gcLo}, // KATAKANA LETTER SMALL YA - {0x30E4, 0x30E4, prID, gcLo}, // KATAKANA LETTER YA - {0x30E5, 0x30E5, prCJ, gcLo}, // KATAKANA LETTER SMALL YU - {0x30E6, 0x30E6, prID, gcLo}, // KATAKANA LETTER YU - {0x30E7, 0x30E7, prCJ, gcLo}, // KATAKANA LETTER SMALL YO - {0x30E8, 0x30ED, prID, gcLo}, // [6] KATAKANA LETTER YO..KATAKANA LETTER RO - {0x30EE, 0x30EE, prCJ, gcLo}, // KATAKANA LETTER SMALL WA - {0x30EF, 0x30F4, prID, gcLo}, // [6] KATAKANA LETTER WA..KATAKANA LETTER VU - {0x30F5, 0x30F6, prCJ, gcLo}, // [2] KATAKANA LETTER SMALL KA..KATAKANA LETTER SMALL KE - {0x30F7, 0x30FA, prID, gcLo}, // [4] KATAKANA LETTER VA..KATAKANA LETTER VO - {0x30FB, 0x30FB, prNS, gcPo}, // KATAKANA MIDDLE DOT - {0x30FC, 0x30FC, prCJ, gcLm}, // KATAKANA-HIRAGANA PROLONGED SOUND MARK - {0x30FD, 0x30FE, prNS, gcLm}, // [2] KATAKANA ITERATION MARK..KATAKANA VOICED ITERATION MARK - {0x30FF, 0x30FF, prID, gcLo}, // KATAKANA DIGRAPH KOTO - {0x3105, 0x312F, prID, gcLo}, // [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN - {0x3131, 0x318E, prID, gcLo}, // [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE - {0x3190, 0x3191, prID, gcSo}, // [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK - {0x3192, 0x3195, prID, gcNo}, // [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK - {0x3196, 0x319F, prID, gcSo}, // [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK - {0x31A0, 0x31BF, prID, gcLo}, // [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH - {0x31C0, 0x31E3, prID, gcSo}, // [36] CJK STROKE T..CJK STROKE Q - {0x31F0, 0x31FF, prCJ, gcLo}, // [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO - {0x3200, 0x321E, prID, gcSo}, // [31] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED KOREAN CHARACTER O HU - {0x3220, 0x3229, prID, gcNo}, // [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN - {0x322A, 0x3247, prID, gcSo}, // [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO - {0x3248, 0x324F, prAI, gcNo}, // [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE - {0x3250, 0x3250, prID, gcSo}, // PARTNERSHIP SIGN - {0x3251, 0x325F, prID, gcNo}, // [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE - {0x3260, 0x327F, prID, gcSo}, // [32] CIRCLED HANGUL KIYEOK..KOREAN STANDARD SYMBOL - {0x3280, 0x3289, prID, gcNo}, // [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN - {0x328A, 0x32B0, prID, gcSo}, // [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT - {0x32B1, 0x32BF, prID, gcNo}, // [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY - {0x32C0, 0x32FF, prID, gcSo}, // [64] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..SQUARE ERA NAME REIWA - {0x3300, 0x33FF, prID, gcSo}, // [256] SQUARE APAATO..SQUARE GAL - {0x3400, 0x4DBF, prID, gcLo}, // [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF - {0x4DC0, 0x4DFF, prAL, gcSo}, // [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION - {0x4E00, 0x9FFF, prID, gcLo}, // [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF - {0xA000, 0xA014, prID, gcLo}, // [21] YI SYLLABLE IT..YI SYLLABLE E - {0xA015, 0xA015, prNS, gcLm}, // YI SYLLABLE WU - {0xA016, 0xA48C, prID, gcLo}, // [1143] YI SYLLABLE BIT..YI SYLLABLE YYR - {0xA490, 0xA4C6, prID, gcSo}, // [55] YI RADICAL QOT..YI RADICAL KE - {0xA4D0, 0xA4F7, prAL, gcLo}, // [40] LISU LETTER BA..LISU LETTER OE - {0xA4F8, 0xA4FD, prAL, gcLm}, // [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU - {0xA4FE, 0xA4FF, prBA, gcPo}, // [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP - {0xA500, 0xA60B, prAL, gcLo}, // [268] VAI SYLLABLE EE..VAI SYLLABLE NG - {0xA60C, 0xA60C, prAL, gcLm}, // VAI SYLLABLE LENGTHENER - {0xA60D, 0xA60D, prBA, gcPo}, // VAI COMMA - {0xA60E, 0xA60E, prEX, gcPo}, // VAI FULL STOP - {0xA60F, 0xA60F, prBA, gcPo}, // VAI QUESTION MARK - {0xA610, 0xA61F, prAL, gcLo}, // [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG - {0xA620, 0xA629, prNU, gcNd}, // [10] VAI DIGIT ZERO..VAI DIGIT NINE - {0xA62A, 0xA62B, prAL, gcLo}, // [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO - {0xA640, 0xA66D, prAL, gcLC}, // [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O - {0xA66E, 0xA66E, prAL, gcLo}, // CYRILLIC LETTER MULTIOCULAR O - {0xA66F, 0xA66F, prCM, gcMn}, // COMBINING CYRILLIC VZMET - {0xA670, 0xA672, prCM, gcMe}, // [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN - {0xA673, 0xA673, prAL, gcPo}, // SLAVONIC ASTERISK - {0xA674, 0xA67D, prCM, gcMn}, // [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK - {0xA67E, 0xA67E, prAL, gcPo}, // CYRILLIC KAVYKA - {0xA67F, 0xA67F, prAL, gcLm}, // CYRILLIC PAYEROK - {0xA680, 0xA69B, prAL, gcLC}, // [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O - {0xA69C, 0xA69D, prAL, gcLm}, // [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN - {0xA69E, 0xA69F, prCM, gcMn}, // [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E - {0xA6A0, 0xA6E5, prAL, gcLo}, // [70] BAMUM LETTER A..BAMUM LETTER KI - {0xA6E6, 0xA6EF, prAL, gcNl}, // [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM - {0xA6F0, 0xA6F1, prCM, gcMn}, // [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS - {0xA6F2, 0xA6F2, prAL, gcPo}, // BAMUM NJAEMLI - {0xA6F3, 0xA6F7, prBA, gcPo}, // [5] BAMUM FULL STOP..BAMUM QUESTION MARK - {0xA700, 0xA716, prAL, gcSk}, // [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR - {0xA717, 0xA71F, prAL, gcLm}, // [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK - {0xA720, 0xA721, prAL, gcSk}, // [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE - {0xA722, 0xA76F, prAL, gcLC}, // [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON - {0xA770, 0xA770, prAL, gcLm}, // MODIFIER LETTER US - {0xA771, 0xA787, prAL, gcLC}, // [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T - {0xA788, 0xA788, prAL, gcLm}, // MODIFIER LETTER LOW CIRCUMFLEX ACCENT - {0xA789, 0xA78A, prAL, gcSk}, // [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN - {0xA78B, 0xA78E, prAL, gcLC}, // [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT - {0xA78F, 0xA78F, prAL, gcLo}, // LATIN LETTER SINOLOGICAL DOT - {0xA790, 0xA7CA, prAL, gcLC}, // [59] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY - {0xA7D0, 0xA7D1, prAL, gcLC}, // [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G - {0xA7D3, 0xA7D3, prAL, gcLl}, // LATIN SMALL LETTER DOUBLE THORN - {0xA7D5, 0xA7D9, prAL, gcLC}, // [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S - {0xA7F2, 0xA7F4, prAL, gcLm}, // [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q - {0xA7F5, 0xA7F6, prAL, gcLC}, // [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H - {0xA7F7, 0xA7F7, prAL, gcLo}, // LATIN EPIGRAPHIC LETTER SIDEWAYS I - {0xA7F8, 0xA7F9, prAL, gcLm}, // [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE - {0xA7FA, 0xA7FA, prAL, gcLl}, // LATIN LETTER SMALL CAPITAL TURNED M - {0xA7FB, 0xA7FF, prAL, gcLo}, // [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M - {0xA800, 0xA801, prAL, gcLo}, // [2] SYLOTI NAGRI LETTER A..SYLOTI NAGRI LETTER I - {0xA802, 0xA802, prCM, gcMn}, // SYLOTI NAGRI SIGN DVISVARA - {0xA803, 0xA805, prAL, gcLo}, // [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O - {0xA806, 0xA806, prCM, gcMn}, // SYLOTI NAGRI SIGN HASANTA - {0xA807, 0xA80A, prAL, gcLo}, // [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO - {0xA80B, 0xA80B, prCM, gcMn}, // SYLOTI NAGRI SIGN ANUSVARA - {0xA80C, 0xA822, prAL, gcLo}, // [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO - {0xA823, 0xA824, prCM, gcMc}, // [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I - {0xA825, 0xA826, prCM, gcMn}, // [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E - {0xA827, 0xA827, prCM, gcMc}, // SYLOTI NAGRI VOWEL SIGN OO - {0xA828, 0xA82B, prAL, gcSo}, // [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4 - {0xA82C, 0xA82C, prCM, gcMn}, // SYLOTI NAGRI SIGN ALTERNATE HASANTA - {0xA830, 0xA835, prAL, gcNo}, // [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS - {0xA836, 0xA837, prAL, gcSo}, // [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK - {0xA838, 0xA838, prPO, gcSc}, // NORTH INDIC RUPEE MARK - {0xA839, 0xA839, prAL, gcSo}, // NORTH INDIC QUANTITY MARK - {0xA840, 0xA873, prAL, gcLo}, // [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU - {0xA874, 0xA875, prBB, gcPo}, // [2] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA DOUBLE HEAD MARK - {0xA876, 0xA877, prEX, gcPo}, // [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD - {0xA880, 0xA881, prCM, gcMc}, // [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA - {0xA882, 0xA8B3, prAL, gcLo}, // [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA - {0xA8B4, 0xA8C3, prCM, gcMc}, // [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU - {0xA8C4, 0xA8C5, prCM, gcMn}, // [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU - {0xA8CE, 0xA8CF, prBA, gcPo}, // [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA - {0xA8D0, 0xA8D9, prNU, gcNd}, // [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE - {0xA8E0, 0xA8F1, prCM, gcMn}, // [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA - {0xA8F2, 0xA8F7, prAL, gcLo}, // [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA - {0xA8F8, 0xA8FA, prAL, gcPo}, // [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET - {0xA8FB, 0xA8FB, prAL, gcLo}, // DEVANAGARI HEADSTROKE - {0xA8FC, 0xA8FC, prBB, gcPo}, // DEVANAGARI SIGN SIDDHAM - {0xA8FD, 0xA8FE, prAL, gcLo}, // [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY - {0xA8FF, 0xA8FF, prCM, gcMn}, // DEVANAGARI VOWEL SIGN AY - {0xA900, 0xA909, prNU, gcNd}, // [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE - {0xA90A, 0xA925, prAL, gcLo}, // [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO - {0xA926, 0xA92D, prCM, gcMn}, // [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU - {0xA92E, 0xA92F, prBA, gcPo}, // [2] KAYAH LI SIGN CWI..KAYAH LI SIGN SHYA - {0xA930, 0xA946, prAL, gcLo}, // [23] REJANG LETTER KA..REJANG LETTER A - {0xA947, 0xA951, prCM, gcMn}, // [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R - {0xA952, 0xA953, prCM, gcMc}, // [2] REJANG CONSONANT SIGN H..REJANG VIRAMA - {0xA95F, 0xA95F, prAL, gcPo}, // REJANG SECTION MARK - {0xA960, 0xA97C, prJL, gcLo}, // [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH - {0xA980, 0xA982, prCM, gcMn}, // [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR - {0xA983, 0xA983, prCM, gcMc}, // JAVANESE SIGN WIGNYAN - {0xA984, 0xA9B2, prAL, gcLo}, // [47] JAVANESE LETTER A..JAVANESE LETTER HA - {0xA9B3, 0xA9B3, prCM, gcMn}, // JAVANESE SIGN CECAK TELU - {0xA9B4, 0xA9B5, prCM, gcMc}, // [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG - {0xA9B6, 0xA9B9, prCM, gcMn}, // [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT - {0xA9BA, 0xA9BB, prCM, gcMc}, // [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE - {0xA9BC, 0xA9BD, prCM, gcMn}, // [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET - {0xA9BE, 0xA9C0, prCM, gcMc}, // [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON - {0xA9C1, 0xA9C6, prAL, gcPo}, // [6] JAVANESE LEFT RERENGGAN..JAVANESE PADA WINDU - {0xA9C7, 0xA9C9, prBA, gcPo}, // [3] JAVANESE PADA PANGKAT..JAVANESE PADA LUNGSI - {0xA9CA, 0xA9CD, prAL, gcPo}, // [4] JAVANESE PADA ADEG..JAVANESE TURNED PADA PISELEH - {0xA9CF, 0xA9CF, prAL, gcLm}, // JAVANESE PANGRANGKEP - {0xA9D0, 0xA9D9, prNU, gcNd}, // [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE - {0xA9DE, 0xA9DF, prAL, gcPo}, // [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN - {0xA9E0, 0xA9E4, prSA, gcLo}, // [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA - {0xA9E5, 0xA9E5, prSA, gcMn}, // MYANMAR SIGN SHAN SAW - {0xA9E6, 0xA9E6, prSA, gcLm}, // MYANMAR MODIFIER LETTER SHAN REDUPLICATION - {0xA9E7, 0xA9EF, prSA, gcLo}, // [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA - {0xA9F0, 0xA9F9, prNU, gcNd}, // [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE - {0xA9FA, 0xA9FE, prSA, gcLo}, // [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA - {0xAA00, 0xAA28, prAL, gcLo}, // [41] CHAM LETTER A..CHAM LETTER HA - {0xAA29, 0xAA2E, prCM, gcMn}, // [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE - {0xAA2F, 0xAA30, prCM, gcMc}, // [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI - {0xAA31, 0xAA32, prCM, gcMn}, // [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE - {0xAA33, 0xAA34, prCM, gcMc}, // [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA - {0xAA35, 0xAA36, prCM, gcMn}, // [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA - {0xAA40, 0xAA42, prAL, gcLo}, // [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG - {0xAA43, 0xAA43, prCM, gcMn}, // CHAM CONSONANT SIGN FINAL NG - {0xAA44, 0xAA4B, prAL, gcLo}, // [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS - {0xAA4C, 0xAA4C, prCM, gcMn}, // CHAM CONSONANT SIGN FINAL M - {0xAA4D, 0xAA4D, prCM, gcMc}, // CHAM CONSONANT SIGN FINAL H - {0xAA50, 0xAA59, prNU, gcNd}, // [10] CHAM DIGIT ZERO..CHAM DIGIT NINE - {0xAA5C, 0xAA5C, prAL, gcPo}, // CHAM PUNCTUATION SPIRAL - {0xAA5D, 0xAA5F, prBA, gcPo}, // [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA - {0xAA60, 0xAA6F, prSA, gcLo}, // [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA - {0xAA70, 0xAA70, prSA, gcLm}, // MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION - {0xAA71, 0xAA76, prSA, gcLo}, // [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM - {0xAA77, 0xAA79, prSA, gcSo}, // [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO - {0xAA7A, 0xAA7A, prSA, gcLo}, // MYANMAR LETTER AITON RA - {0xAA7B, 0xAA7B, prSA, gcMc}, // MYANMAR SIGN PAO KAREN TONE - {0xAA7C, 0xAA7C, prSA, gcMn}, // MYANMAR SIGN TAI LAING TONE-2 - {0xAA7D, 0xAA7D, prSA, gcMc}, // MYANMAR SIGN TAI LAING TONE-5 - {0xAA7E, 0xAA7F, prSA, gcLo}, // [2] MYANMAR LETTER SHWE PALAUNG CHA..MYANMAR LETTER SHWE PALAUNG SHA - {0xAA80, 0xAAAF, prSA, gcLo}, // [48] TAI VIET LETTER LOW KO..TAI VIET LETTER HIGH O - {0xAAB0, 0xAAB0, prSA, gcMn}, // TAI VIET MAI KANG - {0xAAB1, 0xAAB1, prSA, gcLo}, // TAI VIET VOWEL AA - {0xAAB2, 0xAAB4, prSA, gcMn}, // [3] TAI VIET VOWEL I..TAI VIET VOWEL U - {0xAAB5, 0xAAB6, prSA, gcLo}, // [2] TAI VIET VOWEL E..TAI VIET VOWEL O - {0xAAB7, 0xAAB8, prSA, gcMn}, // [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA - {0xAAB9, 0xAABD, prSA, gcLo}, // [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN - {0xAABE, 0xAABF, prSA, gcMn}, // [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK - {0xAAC0, 0xAAC0, prSA, gcLo}, // TAI VIET TONE MAI NUENG - {0xAAC1, 0xAAC1, prSA, gcMn}, // TAI VIET TONE MAI THO - {0xAAC2, 0xAAC2, prSA, gcLo}, // TAI VIET TONE MAI SONG - {0xAADB, 0xAADC, prSA, gcLo}, // [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG - {0xAADD, 0xAADD, prSA, gcLm}, // TAI VIET SYMBOL SAM - {0xAADE, 0xAADF, prSA, gcPo}, // [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI - {0xAAE0, 0xAAEA, prAL, gcLo}, // [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA - {0xAAEB, 0xAAEB, prCM, gcMc}, // MEETEI MAYEK VOWEL SIGN II - {0xAAEC, 0xAAED, prCM, gcMn}, // [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI - {0xAAEE, 0xAAEF, prCM, gcMc}, // [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU - {0xAAF0, 0xAAF1, prBA, gcPo}, // [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM - {0xAAF2, 0xAAF2, prAL, gcLo}, // MEETEI MAYEK ANJI - {0xAAF3, 0xAAF4, prAL, gcLm}, // [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK - {0xAAF5, 0xAAF5, prCM, gcMc}, // MEETEI MAYEK VOWEL SIGN VISARGA - {0xAAF6, 0xAAF6, prCM, gcMn}, // MEETEI MAYEK VIRAMA - {0xAB01, 0xAB06, prAL, gcLo}, // [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO - {0xAB09, 0xAB0E, prAL, gcLo}, // [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO - {0xAB11, 0xAB16, prAL, gcLo}, // [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO - {0xAB20, 0xAB26, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO - {0xAB28, 0xAB2E, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO - {0xAB30, 0xAB5A, prAL, gcLl}, // [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG - {0xAB5B, 0xAB5B, prAL, gcSk}, // MODIFIER BREVE WITH INVERTED BREVE - {0xAB5C, 0xAB5F, prAL, gcLm}, // [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK - {0xAB60, 0xAB68, prAL, gcLl}, // [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE - {0xAB69, 0xAB69, prAL, gcLm}, // MODIFIER LETTER SMALL TURNED W - {0xAB6A, 0xAB6B, prAL, gcSk}, // [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK - {0xAB70, 0xABBF, prAL, gcLl}, // [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA - {0xABC0, 0xABE2, prAL, gcLo}, // [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM - {0xABE3, 0xABE4, prCM, gcMc}, // [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP - {0xABE5, 0xABE5, prCM, gcMn}, // MEETEI MAYEK VOWEL SIGN ANAP - {0xABE6, 0xABE7, prCM, gcMc}, // [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP - {0xABE8, 0xABE8, prCM, gcMn}, // MEETEI MAYEK VOWEL SIGN UNAP - {0xABE9, 0xABEA, prCM, gcMc}, // [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG - {0xABEB, 0xABEB, prBA, gcPo}, // MEETEI MAYEK CHEIKHEI - {0xABEC, 0xABEC, prCM, gcMc}, // MEETEI MAYEK LUM IYEK - {0xABED, 0xABED, prCM, gcMn}, // MEETEI MAYEK APUN IYEK - {0xABF0, 0xABF9, prNU, gcNd}, // [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE - {0xAC00, 0xAC00, prH2, gcLo}, // HANGUL SYLLABLE GA - {0xAC01, 0xAC1B, prH3, gcLo}, // [27] HANGUL SYLLABLE GAG..HANGUL SYLLABLE GAH - {0xAC1C, 0xAC1C, prH2, gcLo}, // HANGUL SYLLABLE GAE - {0xAC1D, 0xAC37, prH3, gcLo}, // [27] HANGUL SYLLABLE GAEG..HANGUL SYLLABLE GAEH - {0xAC38, 0xAC38, prH2, gcLo}, // HANGUL SYLLABLE GYA - {0xAC39, 0xAC53, prH3, gcLo}, // [27] HANGUL SYLLABLE GYAG..HANGUL SYLLABLE GYAH - {0xAC54, 0xAC54, prH2, gcLo}, // HANGUL SYLLABLE GYAE - {0xAC55, 0xAC6F, prH3, gcLo}, // [27] HANGUL SYLLABLE GYAEG..HANGUL SYLLABLE GYAEH - {0xAC70, 0xAC70, prH2, gcLo}, // HANGUL SYLLABLE GEO - {0xAC71, 0xAC8B, prH3, gcLo}, // [27] HANGUL SYLLABLE GEOG..HANGUL SYLLABLE GEOH - {0xAC8C, 0xAC8C, prH2, gcLo}, // HANGUL SYLLABLE GE - {0xAC8D, 0xACA7, prH3, gcLo}, // [27] HANGUL SYLLABLE GEG..HANGUL SYLLABLE GEH - {0xACA8, 0xACA8, prH2, gcLo}, // HANGUL SYLLABLE GYEO - {0xACA9, 0xACC3, prH3, gcLo}, // [27] HANGUL SYLLABLE GYEOG..HANGUL SYLLABLE GYEOH - {0xACC4, 0xACC4, prH2, gcLo}, // HANGUL SYLLABLE GYE - {0xACC5, 0xACDF, prH3, gcLo}, // [27] HANGUL SYLLABLE GYEG..HANGUL SYLLABLE GYEH - {0xACE0, 0xACE0, prH2, gcLo}, // HANGUL SYLLABLE GO - {0xACE1, 0xACFB, prH3, gcLo}, // [27] HANGUL SYLLABLE GOG..HANGUL SYLLABLE GOH - {0xACFC, 0xACFC, prH2, gcLo}, // HANGUL SYLLABLE GWA - {0xACFD, 0xAD17, prH3, gcLo}, // [27] HANGUL SYLLABLE GWAG..HANGUL SYLLABLE GWAH - {0xAD18, 0xAD18, prH2, gcLo}, // HANGUL SYLLABLE GWAE - {0xAD19, 0xAD33, prH3, gcLo}, // [27] HANGUL SYLLABLE GWAEG..HANGUL SYLLABLE GWAEH - {0xAD34, 0xAD34, prH2, gcLo}, // HANGUL SYLLABLE GOE - {0xAD35, 0xAD4F, prH3, gcLo}, // [27] HANGUL SYLLABLE GOEG..HANGUL SYLLABLE GOEH - {0xAD50, 0xAD50, prH2, gcLo}, // HANGUL SYLLABLE GYO - {0xAD51, 0xAD6B, prH3, gcLo}, // [27] HANGUL SYLLABLE GYOG..HANGUL SYLLABLE GYOH - {0xAD6C, 0xAD6C, prH2, gcLo}, // HANGUL SYLLABLE GU - {0xAD6D, 0xAD87, prH3, gcLo}, // [27] HANGUL SYLLABLE GUG..HANGUL SYLLABLE GUH - {0xAD88, 0xAD88, prH2, gcLo}, // HANGUL SYLLABLE GWEO - {0xAD89, 0xADA3, prH3, gcLo}, // [27] HANGUL SYLLABLE GWEOG..HANGUL SYLLABLE GWEOH - {0xADA4, 0xADA4, prH2, gcLo}, // HANGUL SYLLABLE GWE - {0xADA5, 0xADBF, prH3, gcLo}, // [27] HANGUL SYLLABLE GWEG..HANGUL SYLLABLE GWEH - {0xADC0, 0xADC0, prH2, gcLo}, // HANGUL SYLLABLE GWI - {0xADC1, 0xADDB, prH3, gcLo}, // [27] HANGUL SYLLABLE GWIG..HANGUL SYLLABLE GWIH - {0xADDC, 0xADDC, prH2, gcLo}, // HANGUL SYLLABLE GYU - {0xADDD, 0xADF7, prH3, gcLo}, // [27] HANGUL SYLLABLE GYUG..HANGUL SYLLABLE GYUH - {0xADF8, 0xADF8, prH2, gcLo}, // HANGUL SYLLABLE GEU - {0xADF9, 0xAE13, prH3, gcLo}, // [27] HANGUL SYLLABLE GEUG..HANGUL SYLLABLE GEUH - {0xAE14, 0xAE14, prH2, gcLo}, // HANGUL SYLLABLE GYI - {0xAE15, 0xAE2F, prH3, gcLo}, // [27] HANGUL SYLLABLE GYIG..HANGUL SYLLABLE GYIH - {0xAE30, 0xAE30, prH2, gcLo}, // HANGUL SYLLABLE GI - {0xAE31, 0xAE4B, prH3, gcLo}, // [27] HANGUL SYLLABLE GIG..HANGUL SYLLABLE GIH - {0xAE4C, 0xAE4C, prH2, gcLo}, // HANGUL SYLLABLE GGA - {0xAE4D, 0xAE67, prH3, gcLo}, // [27] HANGUL SYLLABLE GGAG..HANGUL SYLLABLE GGAH - {0xAE68, 0xAE68, prH2, gcLo}, // HANGUL SYLLABLE GGAE - {0xAE69, 0xAE83, prH3, gcLo}, // [27] HANGUL SYLLABLE GGAEG..HANGUL SYLLABLE GGAEH - {0xAE84, 0xAE84, prH2, gcLo}, // HANGUL SYLLABLE GGYA - {0xAE85, 0xAE9F, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYAG..HANGUL SYLLABLE GGYAH - {0xAEA0, 0xAEA0, prH2, gcLo}, // HANGUL SYLLABLE GGYAE - {0xAEA1, 0xAEBB, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYAEG..HANGUL SYLLABLE GGYAEH - {0xAEBC, 0xAEBC, prH2, gcLo}, // HANGUL SYLLABLE GGEO - {0xAEBD, 0xAED7, prH3, gcLo}, // [27] HANGUL SYLLABLE GGEOG..HANGUL SYLLABLE GGEOH - {0xAED8, 0xAED8, prH2, gcLo}, // HANGUL SYLLABLE GGE - {0xAED9, 0xAEF3, prH3, gcLo}, // [27] HANGUL SYLLABLE GGEG..HANGUL SYLLABLE GGEH - {0xAEF4, 0xAEF4, prH2, gcLo}, // HANGUL SYLLABLE GGYEO - {0xAEF5, 0xAF0F, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYEOG..HANGUL SYLLABLE GGYEOH - {0xAF10, 0xAF10, prH2, gcLo}, // HANGUL SYLLABLE GGYE - {0xAF11, 0xAF2B, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYEG..HANGUL SYLLABLE GGYEH - {0xAF2C, 0xAF2C, prH2, gcLo}, // HANGUL SYLLABLE GGO - {0xAF2D, 0xAF47, prH3, gcLo}, // [27] HANGUL SYLLABLE GGOG..HANGUL SYLLABLE GGOH - {0xAF48, 0xAF48, prH2, gcLo}, // HANGUL SYLLABLE GGWA - {0xAF49, 0xAF63, prH3, gcLo}, // [27] HANGUL SYLLABLE GGWAG..HANGUL SYLLABLE GGWAH - {0xAF64, 0xAF64, prH2, gcLo}, // HANGUL SYLLABLE GGWAE - {0xAF65, 0xAF7F, prH3, gcLo}, // [27] HANGUL SYLLABLE GGWAEG..HANGUL SYLLABLE GGWAEH - {0xAF80, 0xAF80, prH2, gcLo}, // HANGUL SYLLABLE GGOE - {0xAF81, 0xAF9B, prH3, gcLo}, // [27] HANGUL SYLLABLE GGOEG..HANGUL SYLLABLE GGOEH - {0xAF9C, 0xAF9C, prH2, gcLo}, // HANGUL SYLLABLE GGYO - {0xAF9D, 0xAFB7, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYOG..HANGUL SYLLABLE GGYOH - {0xAFB8, 0xAFB8, prH2, gcLo}, // HANGUL SYLLABLE GGU - {0xAFB9, 0xAFD3, prH3, gcLo}, // [27] HANGUL SYLLABLE GGUG..HANGUL SYLLABLE GGUH - {0xAFD4, 0xAFD4, prH2, gcLo}, // HANGUL SYLLABLE GGWEO - {0xAFD5, 0xAFEF, prH3, gcLo}, // [27] HANGUL SYLLABLE GGWEOG..HANGUL SYLLABLE GGWEOH - {0xAFF0, 0xAFF0, prH2, gcLo}, // HANGUL SYLLABLE GGWE - {0xAFF1, 0xB00B, prH3, gcLo}, // [27] HANGUL SYLLABLE GGWEG..HANGUL SYLLABLE GGWEH - {0xB00C, 0xB00C, prH2, gcLo}, // HANGUL SYLLABLE GGWI - {0xB00D, 0xB027, prH3, gcLo}, // [27] HANGUL SYLLABLE GGWIG..HANGUL SYLLABLE GGWIH - {0xB028, 0xB028, prH2, gcLo}, // HANGUL SYLLABLE GGYU - {0xB029, 0xB043, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYUG..HANGUL SYLLABLE GGYUH - {0xB044, 0xB044, prH2, gcLo}, // HANGUL SYLLABLE GGEU - {0xB045, 0xB05F, prH3, gcLo}, // [27] HANGUL SYLLABLE GGEUG..HANGUL SYLLABLE GGEUH - {0xB060, 0xB060, prH2, gcLo}, // HANGUL SYLLABLE GGYI - {0xB061, 0xB07B, prH3, gcLo}, // [27] HANGUL SYLLABLE GGYIG..HANGUL SYLLABLE GGYIH - {0xB07C, 0xB07C, prH2, gcLo}, // HANGUL SYLLABLE GGI - {0xB07D, 0xB097, prH3, gcLo}, // [27] HANGUL SYLLABLE GGIG..HANGUL SYLLABLE GGIH - {0xB098, 0xB098, prH2, gcLo}, // HANGUL SYLLABLE NA - {0xB099, 0xB0B3, prH3, gcLo}, // [27] HANGUL SYLLABLE NAG..HANGUL SYLLABLE NAH - {0xB0B4, 0xB0B4, prH2, gcLo}, // HANGUL SYLLABLE NAE - {0xB0B5, 0xB0CF, prH3, gcLo}, // [27] HANGUL SYLLABLE NAEG..HANGUL SYLLABLE NAEH - {0xB0D0, 0xB0D0, prH2, gcLo}, // HANGUL SYLLABLE NYA - {0xB0D1, 0xB0EB, prH3, gcLo}, // [27] HANGUL SYLLABLE NYAG..HANGUL SYLLABLE NYAH - {0xB0EC, 0xB0EC, prH2, gcLo}, // HANGUL SYLLABLE NYAE - {0xB0ED, 0xB107, prH3, gcLo}, // [27] HANGUL SYLLABLE NYAEG..HANGUL SYLLABLE NYAEH - {0xB108, 0xB108, prH2, gcLo}, // HANGUL SYLLABLE NEO - {0xB109, 0xB123, prH3, gcLo}, // [27] HANGUL SYLLABLE NEOG..HANGUL SYLLABLE NEOH - {0xB124, 0xB124, prH2, gcLo}, // HANGUL SYLLABLE NE - {0xB125, 0xB13F, prH3, gcLo}, // [27] HANGUL SYLLABLE NEG..HANGUL SYLLABLE NEH - {0xB140, 0xB140, prH2, gcLo}, // HANGUL SYLLABLE NYEO - {0xB141, 0xB15B, prH3, gcLo}, // [27] HANGUL SYLLABLE NYEOG..HANGUL SYLLABLE NYEOH - {0xB15C, 0xB15C, prH2, gcLo}, // HANGUL SYLLABLE NYE - {0xB15D, 0xB177, prH3, gcLo}, // [27] HANGUL SYLLABLE NYEG..HANGUL SYLLABLE NYEH - {0xB178, 0xB178, prH2, gcLo}, // HANGUL SYLLABLE NO - {0xB179, 0xB193, prH3, gcLo}, // [27] HANGUL SYLLABLE NOG..HANGUL SYLLABLE NOH - {0xB194, 0xB194, prH2, gcLo}, // HANGUL SYLLABLE NWA - {0xB195, 0xB1AF, prH3, gcLo}, // [27] HANGUL SYLLABLE NWAG..HANGUL SYLLABLE NWAH - {0xB1B0, 0xB1B0, prH2, gcLo}, // HANGUL SYLLABLE NWAE - {0xB1B1, 0xB1CB, prH3, gcLo}, // [27] HANGUL SYLLABLE NWAEG..HANGUL SYLLABLE NWAEH - {0xB1CC, 0xB1CC, prH2, gcLo}, // HANGUL SYLLABLE NOE - {0xB1CD, 0xB1E7, prH3, gcLo}, // [27] HANGUL SYLLABLE NOEG..HANGUL SYLLABLE NOEH - {0xB1E8, 0xB1E8, prH2, gcLo}, // HANGUL SYLLABLE NYO - {0xB1E9, 0xB203, prH3, gcLo}, // [27] HANGUL SYLLABLE NYOG..HANGUL SYLLABLE NYOH - {0xB204, 0xB204, prH2, gcLo}, // HANGUL SYLLABLE NU - {0xB205, 0xB21F, prH3, gcLo}, // [27] HANGUL SYLLABLE NUG..HANGUL SYLLABLE NUH - {0xB220, 0xB220, prH2, gcLo}, // HANGUL SYLLABLE NWEO - {0xB221, 0xB23B, prH3, gcLo}, // [27] HANGUL SYLLABLE NWEOG..HANGUL SYLLABLE NWEOH - {0xB23C, 0xB23C, prH2, gcLo}, // HANGUL SYLLABLE NWE - {0xB23D, 0xB257, prH3, gcLo}, // [27] HANGUL SYLLABLE NWEG..HANGUL SYLLABLE NWEH - {0xB258, 0xB258, prH2, gcLo}, // HANGUL SYLLABLE NWI - {0xB259, 0xB273, prH3, gcLo}, // [27] HANGUL SYLLABLE NWIG..HANGUL SYLLABLE NWIH - {0xB274, 0xB274, prH2, gcLo}, // HANGUL SYLLABLE NYU - {0xB275, 0xB28F, prH3, gcLo}, // [27] HANGUL SYLLABLE NYUG..HANGUL SYLLABLE NYUH - {0xB290, 0xB290, prH2, gcLo}, // HANGUL SYLLABLE NEU - {0xB291, 0xB2AB, prH3, gcLo}, // [27] HANGUL SYLLABLE NEUG..HANGUL SYLLABLE NEUH - {0xB2AC, 0xB2AC, prH2, gcLo}, // HANGUL SYLLABLE NYI - {0xB2AD, 0xB2C7, prH3, gcLo}, // [27] HANGUL SYLLABLE NYIG..HANGUL SYLLABLE NYIH - {0xB2C8, 0xB2C8, prH2, gcLo}, // HANGUL SYLLABLE NI - {0xB2C9, 0xB2E3, prH3, gcLo}, // [27] HANGUL SYLLABLE NIG..HANGUL SYLLABLE NIH - {0xB2E4, 0xB2E4, prH2, gcLo}, // HANGUL SYLLABLE DA - {0xB2E5, 0xB2FF, prH3, gcLo}, // [27] HANGUL SYLLABLE DAG..HANGUL SYLLABLE DAH - {0xB300, 0xB300, prH2, gcLo}, // HANGUL SYLLABLE DAE - {0xB301, 0xB31B, prH3, gcLo}, // [27] HANGUL SYLLABLE DAEG..HANGUL SYLLABLE DAEH - {0xB31C, 0xB31C, prH2, gcLo}, // HANGUL SYLLABLE DYA - {0xB31D, 0xB337, prH3, gcLo}, // [27] HANGUL SYLLABLE DYAG..HANGUL SYLLABLE DYAH - {0xB338, 0xB338, prH2, gcLo}, // HANGUL SYLLABLE DYAE - {0xB339, 0xB353, prH3, gcLo}, // [27] HANGUL SYLLABLE DYAEG..HANGUL SYLLABLE DYAEH - {0xB354, 0xB354, prH2, gcLo}, // HANGUL SYLLABLE DEO - {0xB355, 0xB36F, prH3, gcLo}, // [27] HANGUL SYLLABLE DEOG..HANGUL SYLLABLE DEOH - {0xB370, 0xB370, prH2, gcLo}, // HANGUL SYLLABLE DE - {0xB371, 0xB38B, prH3, gcLo}, // [27] HANGUL SYLLABLE DEG..HANGUL SYLLABLE DEH - {0xB38C, 0xB38C, prH2, gcLo}, // HANGUL SYLLABLE DYEO - {0xB38D, 0xB3A7, prH3, gcLo}, // [27] HANGUL SYLLABLE DYEOG..HANGUL SYLLABLE DYEOH - {0xB3A8, 0xB3A8, prH2, gcLo}, // HANGUL SYLLABLE DYE - {0xB3A9, 0xB3C3, prH3, gcLo}, // [27] HANGUL SYLLABLE DYEG..HANGUL SYLLABLE DYEH - {0xB3C4, 0xB3C4, prH2, gcLo}, // HANGUL SYLLABLE DO - {0xB3C5, 0xB3DF, prH3, gcLo}, // [27] HANGUL SYLLABLE DOG..HANGUL SYLLABLE DOH - {0xB3E0, 0xB3E0, prH2, gcLo}, // HANGUL SYLLABLE DWA - {0xB3E1, 0xB3FB, prH3, gcLo}, // [27] HANGUL SYLLABLE DWAG..HANGUL SYLLABLE DWAH - {0xB3FC, 0xB3FC, prH2, gcLo}, // HANGUL SYLLABLE DWAE - {0xB3FD, 0xB417, prH3, gcLo}, // [27] HANGUL SYLLABLE DWAEG..HANGUL SYLLABLE DWAEH - {0xB418, 0xB418, prH2, gcLo}, // HANGUL SYLLABLE DOE - {0xB419, 0xB433, prH3, gcLo}, // [27] HANGUL SYLLABLE DOEG..HANGUL SYLLABLE DOEH - {0xB434, 0xB434, prH2, gcLo}, // HANGUL SYLLABLE DYO - {0xB435, 0xB44F, prH3, gcLo}, // [27] HANGUL SYLLABLE DYOG..HANGUL SYLLABLE DYOH - {0xB450, 0xB450, prH2, gcLo}, // HANGUL SYLLABLE DU - {0xB451, 0xB46B, prH3, gcLo}, // [27] HANGUL SYLLABLE DUG..HANGUL SYLLABLE DUH - {0xB46C, 0xB46C, prH2, gcLo}, // HANGUL SYLLABLE DWEO - {0xB46D, 0xB487, prH3, gcLo}, // [27] HANGUL SYLLABLE DWEOG..HANGUL SYLLABLE DWEOH - {0xB488, 0xB488, prH2, gcLo}, // HANGUL SYLLABLE DWE - {0xB489, 0xB4A3, prH3, gcLo}, // [27] HANGUL SYLLABLE DWEG..HANGUL SYLLABLE DWEH - {0xB4A4, 0xB4A4, prH2, gcLo}, // HANGUL SYLLABLE DWI - {0xB4A5, 0xB4BF, prH3, gcLo}, // [27] HANGUL SYLLABLE DWIG..HANGUL SYLLABLE DWIH - {0xB4C0, 0xB4C0, prH2, gcLo}, // HANGUL SYLLABLE DYU - {0xB4C1, 0xB4DB, prH3, gcLo}, // [27] HANGUL SYLLABLE DYUG..HANGUL SYLLABLE DYUH - {0xB4DC, 0xB4DC, prH2, gcLo}, // HANGUL SYLLABLE DEU - {0xB4DD, 0xB4F7, prH3, gcLo}, // [27] HANGUL SYLLABLE DEUG..HANGUL SYLLABLE DEUH - {0xB4F8, 0xB4F8, prH2, gcLo}, // HANGUL SYLLABLE DYI - {0xB4F9, 0xB513, prH3, gcLo}, // [27] HANGUL SYLLABLE DYIG..HANGUL SYLLABLE DYIH - {0xB514, 0xB514, prH2, gcLo}, // HANGUL SYLLABLE DI - {0xB515, 0xB52F, prH3, gcLo}, // [27] HANGUL SYLLABLE DIG..HANGUL SYLLABLE DIH - {0xB530, 0xB530, prH2, gcLo}, // HANGUL SYLLABLE DDA - {0xB531, 0xB54B, prH3, gcLo}, // [27] HANGUL SYLLABLE DDAG..HANGUL SYLLABLE DDAH - {0xB54C, 0xB54C, prH2, gcLo}, // HANGUL SYLLABLE DDAE - {0xB54D, 0xB567, prH3, gcLo}, // [27] HANGUL SYLLABLE DDAEG..HANGUL SYLLABLE DDAEH - {0xB568, 0xB568, prH2, gcLo}, // HANGUL SYLLABLE DDYA - {0xB569, 0xB583, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYAG..HANGUL SYLLABLE DDYAH - {0xB584, 0xB584, prH2, gcLo}, // HANGUL SYLLABLE DDYAE - {0xB585, 0xB59F, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYAEG..HANGUL SYLLABLE DDYAEH - {0xB5A0, 0xB5A0, prH2, gcLo}, // HANGUL SYLLABLE DDEO - {0xB5A1, 0xB5BB, prH3, gcLo}, // [27] HANGUL SYLLABLE DDEOG..HANGUL SYLLABLE DDEOH - {0xB5BC, 0xB5BC, prH2, gcLo}, // HANGUL SYLLABLE DDE - {0xB5BD, 0xB5D7, prH3, gcLo}, // [27] HANGUL SYLLABLE DDEG..HANGUL SYLLABLE DDEH - {0xB5D8, 0xB5D8, prH2, gcLo}, // HANGUL SYLLABLE DDYEO - {0xB5D9, 0xB5F3, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYEOG..HANGUL SYLLABLE DDYEOH - {0xB5F4, 0xB5F4, prH2, gcLo}, // HANGUL SYLLABLE DDYE - {0xB5F5, 0xB60F, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYEG..HANGUL SYLLABLE DDYEH - {0xB610, 0xB610, prH2, gcLo}, // HANGUL SYLLABLE DDO - {0xB611, 0xB62B, prH3, gcLo}, // [27] HANGUL SYLLABLE DDOG..HANGUL SYLLABLE DDOH - {0xB62C, 0xB62C, prH2, gcLo}, // HANGUL SYLLABLE DDWA - {0xB62D, 0xB647, prH3, gcLo}, // [27] HANGUL SYLLABLE DDWAG..HANGUL SYLLABLE DDWAH - {0xB648, 0xB648, prH2, gcLo}, // HANGUL SYLLABLE DDWAE - {0xB649, 0xB663, prH3, gcLo}, // [27] HANGUL SYLLABLE DDWAEG..HANGUL SYLLABLE DDWAEH - {0xB664, 0xB664, prH2, gcLo}, // HANGUL SYLLABLE DDOE - {0xB665, 0xB67F, prH3, gcLo}, // [27] HANGUL SYLLABLE DDOEG..HANGUL SYLLABLE DDOEH - {0xB680, 0xB680, prH2, gcLo}, // HANGUL SYLLABLE DDYO - {0xB681, 0xB69B, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYOG..HANGUL SYLLABLE DDYOH - {0xB69C, 0xB69C, prH2, gcLo}, // HANGUL SYLLABLE DDU - {0xB69D, 0xB6B7, prH3, gcLo}, // [27] HANGUL SYLLABLE DDUG..HANGUL SYLLABLE DDUH - {0xB6B8, 0xB6B8, prH2, gcLo}, // HANGUL SYLLABLE DDWEO - {0xB6B9, 0xB6D3, prH3, gcLo}, // [27] HANGUL SYLLABLE DDWEOG..HANGUL SYLLABLE DDWEOH - {0xB6D4, 0xB6D4, prH2, gcLo}, // HANGUL SYLLABLE DDWE - {0xB6D5, 0xB6EF, prH3, gcLo}, // [27] HANGUL SYLLABLE DDWEG..HANGUL SYLLABLE DDWEH - {0xB6F0, 0xB6F0, prH2, gcLo}, // HANGUL SYLLABLE DDWI - {0xB6F1, 0xB70B, prH3, gcLo}, // [27] HANGUL SYLLABLE DDWIG..HANGUL SYLLABLE DDWIH - {0xB70C, 0xB70C, prH2, gcLo}, // HANGUL SYLLABLE DDYU - {0xB70D, 0xB727, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYUG..HANGUL SYLLABLE DDYUH - {0xB728, 0xB728, prH2, gcLo}, // HANGUL SYLLABLE DDEU - {0xB729, 0xB743, prH3, gcLo}, // [27] HANGUL SYLLABLE DDEUG..HANGUL SYLLABLE DDEUH - {0xB744, 0xB744, prH2, gcLo}, // HANGUL SYLLABLE DDYI - {0xB745, 0xB75F, prH3, gcLo}, // [27] HANGUL SYLLABLE DDYIG..HANGUL SYLLABLE DDYIH - {0xB760, 0xB760, prH2, gcLo}, // HANGUL SYLLABLE DDI - {0xB761, 0xB77B, prH3, gcLo}, // [27] HANGUL SYLLABLE DDIG..HANGUL SYLLABLE DDIH - {0xB77C, 0xB77C, prH2, gcLo}, // HANGUL SYLLABLE RA - {0xB77D, 0xB797, prH3, gcLo}, // [27] HANGUL SYLLABLE RAG..HANGUL SYLLABLE RAH - {0xB798, 0xB798, prH2, gcLo}, // HANGUL SYLLABLE RAE - {0xB799, 0xB7B3, prH3, gcLo}, // [27] HANGUL SYLLABLE RAEG..HANGUL SYLLABLE RAEH - {0xB7B4, 0xB7B4, prH2, gcLo}, // HANGUL SYLLABLE RYA - {0xB7B5, 0xB7CF, prH3, gcLo}, // [27] HANGUL SYLLABLE RYAG..HANGUL SYLLABLE RYAH - {0xB7D0, 0xB7D0, prH2, gcLo}, // HANGUL SYLLABLE RYAE - {0xB7D1, 0xB7EB, prH3, gcLo}, // [27] HANGUL SYLLABLE RYAEG..HANGUL SYLLABLE RYAEH - {0xB7EC, 0xB7EC, prH2, gcLo}, // HANGUL SYLLABLE REO - {0xB7ED, 0xB807, prH3, gcLo}, // [27] HANGUL SYLLABLE REOG..HANGUL SYLLABLE REOH - {0xB808, 0xB808, prH2, gcLo}, // HANGUL SYLLABLE RE - {0xB809, 0xB823, prH3, gcLo}, // [27] HANGUL SYLLABLE REG..HANGUL SYLLABLE REH - {0xB824, 0xB824, prH2, gcLo}, // HANGUL SYLLABLE RYEO - {0xB825, 0xB83F, prH3, gcLo}, // [27] HANGUL SYLLABLE RYEOG..HANGUL SYLLABLE RYEOH - {0xB840, 0xB840, prH2, gcLo}, // HANGUL SYLLABLE RYE - {0xB841, 0xB85B, prH3, gcLo}, // [27] HANGUL SYLLABLE RYEG..HANGUL SYLLABLE RYEH - {0xB85C, 0xB85C, prH2, gcLo}, // HANGUL SYLLABLE RO - {0xB85D, 0xB877, prH3, gcLo}, // [27] HANGUL SYLLABLE ROG..HANGUL SYLLABLE ROH - {0xB878, 0xB878, prH2, gcLo}, // HANGUL SYLLABLE RWA - {0xB879, 0xB893, prH3, gcLo}, // [27] HANGUL SYLLABLE RWAG..HANGUL SYLLABLE RWAH - {0xB894, 0xB894, prH2, gcLo}, // HANGUL SYLLABLE RWAE - {0xB895, 0xB8AF, prH3, gcLo}, // [27] HANGUL SYLLABLE RWAEG..HANGUL SYLLABLE RWAEH - {0xB8B0, 0xB8B0, prH2, gcLo}, // HANGUL SYLLABLE ROE - {0xB8B1, 0xB8CB, prH3, gcLo}, // [27] HANGUL SYLLABLE ROEG..HANGUL SYLLABLE ROEH - {0xB8CC, 0xB8CC, prH2, gcLo}, // HANGUL SYLLABLE RYO - {0xB8CD, 0xB8E7, prH3, gcLo}, // [27] HANGUL SYLLABLE RYOG..HANGUL SYLLABLE RYOH - {0xB8E8, 0xB8E8, prH2, gcLo}, // HANGUL SYLLABLE RU - {0xB8E9, 0xB903, prH3, gcLo}, // [27] HANGUL SYLLABLE RUG..HANGUL SYLLABLE RUH - {0xB904, 0xB904, prH2, gcLo}, // HANGUL SYLLABLE RWEO - {0xB905, 0xB91F, prH3, gcLo}, // [27] HANGUL SYLLABLE RWEOG..HANGUL SYLLABLE RWEOH - {0xB920, 0xB920, prH2, gcLo}, // HANGUL SYLLABLE RWE - {0xB921, 0xB93B, prH3, gcLo}, // [27] HANGUL SYLLABLE RWEG..HANGUL SYLLABLE RWEH - {0xB93C, 0xB93C, prH2, gcLo}, // HANGUL SYLLABLE RWI - {0xB93D, 0xB957, prH3, gcLo}, // [27] HANGUL SYLLABLE RWIG..HANGUL SYLLABLE RWIH - {0xB958, 0xB958, prH2, gcLo}, // HANGUL SYLLABLE RYU - {0xB959, 0xB973, prH3, gcLo}, // [27] HANGUL SYLLABLE RYUG..HANGUL SYLLABLE RYUH - {0xB974, 0xB974, prH2, gcLo}, // HANGUL SYLLABLE REU - {0xB975, 0xB98F, prH3, gcLo}, // [27] HANGUL SYLLABLE REUG..HANGUL SYLLABLE REUH - {0xB990, 0xB990, prH2, gcLo}, // HANGUL SYLLABLE RYI - {0xB991, 0xB9AB, prH3, gcLo}, // [27] HANGUL SYLLABLE RYIG..HANGUL SYLLABLE RYIH - {0xB9AC, 0xB9AC, prH2, gcLo}, // HANGUL SYLLABLE RI - {0xB9AD, 0xB9C7, prH3, gcLo}, // [27] HANGUL SYLLABLE RIG..HANGUL SYLLABLE RIH - {0xB9C8, 0xB9C8, prH2, gcLo}, // HANGUL SYLLABLE MA - {0xB9C9, 0xB9E3, prH3, gcLo}, // [27] HANGUL SYLLABLE MAG..HANGUL SYLLABLE MAH - {0xB9E4, 0xB9E4, prH2, gcLo}, // HANGUL SYLLABLE MAE - {0xB9E5, 0xB9FF, prH3, gcLo}, // [27] HANGUL SYLLABLE MAEG..HANGUL SYLLABLE MAEH - {0xBA00, 0xBA00, prH2, gcLo}, // HANGUL SYLLABLE MYA - {0xBA01, 0xBA1B, prH3, gcLo}, // [27] HANGUL SYLLABLE MYAG..HANGUL SYLLABLE MYAH - {0xBA1C, 0xBA1C, prH2, gcLo}, // HANGUL SYLLABLE MYAE - {0xBA1D, 0xBA37, prH3, gcLo}, // [27] HANGUL SYLLABLE MYAEG..HANGUL SYLLABLE MYAEH - {0xBA38, 0xBA38, prH2, gcLo}, // HANGUL SYLLABLE MEO - {0xBA39, 0xBA53, prH3, gcLo}, // [27] HANGUL SYLLABLE MEOG..HANGUL SYLLABLE MEOH - {0xBA54, 0xBA54, prH2, gcLo}, // HANGUL SYLLABLE ME - {0xBA55, 0xBA6F, prH3, gcLo}, // [27] HANGUL SYLLABLE MEG..HANGUL SYLLABLE MEH - {0xBA70, 0xBA70, prH2, gcLo}, // HANGUL SYLLABLE MYEO - {0xBA71, 0xBA8B, prH3, gcLo}, // [27] HANGUL SYLLABLE MYEOG..HANGUL SYLLABLE MYEOH - {0xBA8C, 0xBA8C, prH2, gcLo}, // HANGUL SYLLABLE MYE - {0xBA8D, 0xBAA7, prH3, gcLo}, // [27] HANGUL SYLLABLE MYEG..HANGUL SYLLABLE MYEH - {0xBAA8, 0xBAA8, prH2, gcLo}, // HANGUL SYLLABLE MO - {0xBAA9, 0xBAC3, prH3, gcLo}, // [27] HANGUL SYLLABLE MOG..HANGUL SYLLABLE MOH - {0xBAC4, 0xBAC4, prH2, gcLo}, // HANGUL SYLLABLE MWA - {0xBAC5, 0xBADF, prH3, gcLo}, // [27] HANGUL SYLLABLE MWAG..HANGUL SYLLABLE MWAH - {0xBAE0, 0xBAE0, prH2, gcLo}, // HANGUL SYLLABLE MWAE - {0xBAE1, 0xBAFB, prH3, gcLo}, // [27] HANGUL SYLLABLE MWAEG..HANGUL SYLLABLE MWAEH - {0xBAFC, 0xBAFC, prH2, gcLo}, // HANGUL SYLLABLE MOE - {0xBAFD, 0xBB17, prH3, gcLo}, // [27] HANGUL SYLLABLE MOEG..HANGUL SYLLABLE MOEH - {0xBB18, 0xBB18, prH2, gcLo}, // HANGUL SYLLABLE MYO - {0xBB19, 0xBB33, prH3, gcLo}, // [27] HANGUL SYLLABLE MYOG..HANGUL SYLLABLE MYOH - {0xBB34, 0xBB34, prH2, gcLo}, // HANGUL SYLLABLE MU - {0xBB35, 0xBB4F, prH3, gcLo}, // [27] HANGUL SYLLABLE MUG..HANGUL SYLLABLE MUH - {0xBB50, 0xBB50, prH2, gcLo}, // HANGUL SYLLABLE MWEO - {0xBB51, 0xBB6B, prH3, gcLo}, // [27] HANGUL SYLLABLE MWEOG..HANGUL SYLLABLE MWEOH - {0xBB6C, 0xBB6C, prH2, gcLo}, // HANGUL SYLLABLE MWE - {0xBB6D, 0xBB87, prH3, gcLo}, // [27] HANGUL SYLLABLE MWEG..HANGUL SYLLABLE MWEH - {0xBB88, 0xBB88, prH2, gcLo}, // HANGUL SYLLABLE MWI - {0xBB89, 0xBBA3, prH3, gcLo}, // [27] HANGUL SYLLABLE MWIG..HANGUL SYLLABLE MWIH - {0xBBA4, 0xBBA4, prH2, gcLo}, // HANGUL SYLLABLE MYU - {0xBBA5, 0xBBBF, prH3, gcLo}, // [27] HANGUL SYLLABLE MYUG..HANGUL SYLLABLE MYUH - {0xBBC0, 0xBBC0, prH2, gcLo}, // HANGUL SYLLABLE MEU - {0xBBC1, 0xBBDB, prH3, gcLo}, // [27] HANGUL SYLLABLE MEUG..HANGUL SYLLABLE MEUH - {0xBBDC, 0xBBDC, prH2, gcLo}, // HANGUL SYLLABLE MYI - {0xBBDD, 0xBBF7, prH3, gcLo}, // [27] HANGUL SYLLABLE MYIG..HANGUL SYLLABLE MYIH - {0xBBF8, 0xBBF8, prH2, gcLo}, // HANGUL SYLLABLE MI - {0xBBF9, 0xBC13, prH3, gcLo}, // [27] HANGUL SYLLABLE MIG..HANGUL SYLLABLE MIH - {0xBC14, 0xBC14, prH2, gcLo}, // HANGUL SYLLABLE BA - {0xBC15, 0xBC2F, prH3, gcLo}, // [27] HANGUL SYLLABLE BAG..HANGUL SYLLABLE BAH - {0xBC30, 0xBC30, prH2, gcLo}, // HANGUL SYLLABLE BAE - {0xBC31, 0xBC4B, prH3, gcLo}, // [27] HANGUL SYLLABLE BAEG..HANGUL SYLLABLE BAEH - {0xBC4C, 0xBC4C, prH2, gcLo}, // HANGUL SYLLABLE BYA - {0xBC4D, 0xBC67, prH3, gcLo}, // [27] HANGUL SYLLABLE BYAG..HANGUL SYLLABLE BYAH - {0xBC68, 0xBC68, prH2, gcLo}, // HANGUL SYLLABLE BYAE - {0xBC69, 0xBC83, prH3, gcLo}, // [27] HANGUL SYLLABLE BYAEG..HANGUL SYLLABLE BYAEH - {0xBC84, 0xBC84, prH2, gcLo}, // HANGUL SYLLABLE BEO - {0xBC85, 0xBC9F, prH3, gcLo}, // [27] HANGUL SYLLABLE BEOG..HANGUL SYLLABLE BEOH - {0xBCA0, 0xBCA0, prH2, gcLo}, // HANGUL SYLLABLE BE - {0xBCA1, 0xBCBB, prH3, gcLo}, // [27] HANGUL SYLLABLE BEG..HANGUL SYLLABLE BEH - {0xBCBC, 0xBCBC, prH2, gcLo}, // HANGUL SYLLABLE BYEO - {0xBCBD, 0xBCD7, prH3, gcLo}, // [27] HANGUL SYLLABLE BYEOG..HANGUL SYLLABLE BYEOH - {0xBCD8, 0xBCD8, prH2, gcLo}, // HANGUL SYLLABLE BYE - {0xBCD9, 0xBCF3, prH3, gcLo}, // [27] HANGUL SYLLABLE BYEG..HANGUL SYLLABLE BYEH - {0xBCF4, 0xBCF4, prH2, gcLo}, // HANGUL SYLLABLE BO - {0xBCF5, 0xBD0F, prH3, gcLo}, // [27] HANGUL SYLLABLE BOG..HANGUL SYLLABLE BOH - {0xBD10, 0xBD10, prH2, gcLo}, // HANGUL SYLLABLE BWA - {0xBD11, 0xBD2B, prH3, gcLo}, // [27] HANGUL SYLLABLE BWAG..HANGUL SYLLABLE BWAH - {0xBD2C, 0xBD2C, prH2, gcLo}, // HANGUL SYLLABLE BWAE - {0xBD2D, 0xBD47, prH3, gcLo}, // [27] HANGUL SYLLABLE BWAEG..HANGUL SYLLABLE BWAEH - {0xBD48, 0xBD48, prH2, gcLo}, // HANGUL SYLLABLE BOE - {0xBD49, 0xBD63, prH3, gcLo}, // [27] HANGUL SYLLABLE BOEG..HANGUL SYLLABLE BOEH - {0xBD64, 0xBD64, prH2, gcLo}, // HANGUL SYLLABLE BYO - {0xBD65, 0xBD7F, prH3, gcLo}, // [27] HANGUL SYLLABLE BYOG..HANGUL SYLLABLE BYOH - {0xBD80, 0xBD80, prH2, gcLo}, // HANGUL SYLLABLE BU - {0xBD81, 0xBD9B, prH3, gcLo}, // [27] HANGUL SYLLABLE BUG..HANGUL SYLLABLE BUH - {0xBD9C, 0xBD9C, prH2, gcLo}, // HANGUL SYLLABLE BWEO - {0xBD9D, 0xBDB7, prH3, gcLo}, // [27] HANGUL SYLLABLE BWEOG..HANGUL SYLLABLE BWEOH - {0xBDB8, 0xBDB8, prH2, gcLo}, // HANGUL SYLLABLE BWE - {0xBDB9, 0xBDD3, prH3, gcLo}, // [27] HANGUL SYLLABLE BWEG..HANGUL SYLLABLE BWEH - {0xBDD4, 0xBDD4, prH2, gcLo}, // HANGUL SYLLABLE BWI - {0xBDD5, 0xBDEF, prH3, gcLo}, // [27] HANGUL SYLLABLE BWIG..HANGUL SYLLABLE BWIH - {0xBDF0, 0xBDF0, prH2, gcLo}, // HANGUL SYLLABLE BYU - {0xBDF1, 0xBE0B, prH3, gcLo}, // [27] HANGUL SYLLABLE BYUG..HANGUL SYLLABLE BYUH - {0xBE0C, 0xBE0C, prH2, gcLo}, // HANGUL SYLLABLE BEU - {0xBE0D, 0xBE27, prH3, gcLo}, // [27] HANGUL SYLLABLE BEUG..HANGUL SYLLABLE BEUH - {0xBE28, 0xBE28, prH2, gcLo}, // HANGUL SYLLABLE BYI - {0xBE29, 0xBE43, prH3, gcLo}, // [27] HANGUL SYLLABLE BYIG..HANGUL SYLLABLE BYIH - {0xBE44, 0xBE44, prH2, gcLo}, // HANGUL SYLLABLE BI - {0xBE45, 0xBE5F, prH3, gcLo}, // [27] HANGUL SYLLABLE BIG..HANGUL SYLLABLE BIH - {0xBE60, 0xBE60, prH2, gcLo}, // HANGUL SYLLABLE BBA - {0xBE61, 0xBE7B, prH3, gcLo}, // [27] HANGUL SYLLABLE BBAG..HANGUL SYLLABLE BBAH - {0xBE7C, 0xBE7C, prH2, gcLo}, // HANGUL SYLLABLE BBAE - {0xBE7D, 0xBE97, prH3, gcLo}, // [27] HANGUL SYLLABLE BBAEG..HANGUL SYLLABLE BBAEH - {0xBE98, 0xBE98, prH2, gcLo}, // HANGUL SYLLABLE BBYA - {0xBE99, 0xBEB3, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYAG..HANGUL SYLLABLE BBYAH - {0xBEB4, 0xBEB4, prH2, gcLo}, // HANGUL SYLLABLE BBYAE - {0xBEB5, 0xBECF, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYAEG..HANGUL SYLLABLE BBYAEH - {0xBED0, 0xBED0, prH2, gcLo}, // HANGUL SYLLABLE BBEO - {0xBED1, 0xBEEB, prH3, gcLo}, // [27] HANGUL SYLLABLE BBEOG..HANGUL SYLLABLE BBEOH - {0xBEEC, 0xBEEC, prH2, gcLo}, // HANGUL SYLLABLE BBE - {0xBEED, 0xBF07, prH3, gcLo}, // [27] HANGUL SYLLABLE BBEG..HANGUL SYLLABLE BBEH - {0xBF08, 0xBF08, prH2, gcLo}, // HANGUL SYLLABLE BBYEO - {0xBF09, 0xBF23, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYEOG..HANGUL SYLLABLE BBYEOH - {0xBF24, 0xBF24, prH2, gcLo}, // HANGUL SYLLABLE BBYE - {0xBF25, 0xBF3F, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYEG..HANGUL SYLLABLE BBYEH - {0xBF40, 0xBF40, prH2, gcLo}, // HANGUL SYLLABLE BBO - {0xBF41, 0xBF5B, prH3, gcLo}, // [27] HANGUL SYLLABLE BBOG..HANGUL SYLLABLE BBOH - {0xBF5C, 0xBF5C, prH2, gcLo}, // HANGUL SYLLABLE BBWA - {0xBF5D, 0xBF77, prH3, gcLo}, // [27] HANGUL SYLLABLE BBWAG..HANGUL SYLLABLE BBWAH - {0xBF78, 0xBF78, prH2, gcLo}, // HANGUL SYLLABLE BBWAE - {0xBF79, 0xBF93, prH3, gcLo}, // [27] HANGUL SYLLABLE BBWAEG..HANGUL SYLLABLE BBWAEH - {0xBF94, 0xBF94, prH2, gcLo}, // HANGUL SYLLABLE BBOE - {0xBF95, 0xBFAF, prH3, gcLo}, // [27] HANGUL SYLLABLE BBOEG..HANGUL SYLLABLE BBOEH - {0xBFB0, 0xBFB0, prH2, gcLo}, // HANGUL SYLLABLE BBYO - {0xBFB1, 0xBFCB, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYOG..HANGUL SYLLABLE BBYOH - {0xBFCC, 0xBFCC, prH2, gcLo}, // HANGUL SYLLABLE BBU - {0xBFCD, 0xBFE7, prH3, gcLo}, // [27] HANGUL SYLLABLE BBUG..HANGUL SYLLABLE BBUH - {0xBFE8, 0xBFE8, prH2, gcLo}, // HANGUL SYLLABLE BBWEO - {0xBFE9, 0xC003, prH3, gcLo}, // [27] HANGUL SYLLABLE BBWEOG..HANGUL SYLLABLE BBWEOH - {0xC004, 0xC004, prH2, gcLo}, // HANGUL SYLLABLE BBWE - {0xC005, 0xC01F, prH3, gcLo}, // [27] HANGUL SYLLABLE BBWEG..HANGUL SYLLABLE BBWEH - {0xC020, 0xC020, prH2, gcLo}, // HANGUL SYLLABLE BBWI - {0xC021, 0xC03B, prH3, gcLo}, // [27] HANGUL SYLLABLE BBWIG..HANGUL SYLLABLE BBWIH - {0xC03C, 0xC03C, prH2, gcLo}, // HANGUL SYLLABLE BBYU - {0xC03D, 0xC057, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYUG..HANGUL SYLLABLE BBYUH - {0xC058, 0xC058, prH2, gcLo}, // HANGUL SYLLABLE BBEU - {0xC059, 0xC073, prH3, gcLo}, // [27] HANGUL SYLLABLE BBEUG..HANGUL SYLLABLE BBEUH - {0xC074, 0xC074, prH2, gcLo}, // HANGUL SYLLABLE BBYI - {0xC075, 0xC08F, prH3, gcLo}, // [27] HANGUL SYLLABLE BBYIG..HANGUL SYLLABLE BBYIH - {0xC090, 0xC090, prH2, gcLo}, // HANGUL SYLLABLE BBI - {0xC091, 0xC0AB, prH3, gcLo}, // [27] HANGUL SYLLABLE BBIG..HANGUL SYLLABLE BBIH - {0xC0AC, 0xC0AC, prH2, gcLo}, // HANGUL SYLLABLE SA - {0xC0AD, 0xC0C7, prH3, gcLo}, // [27] HANGUL SYLLABLE SAG..HANGUL SYLLABLE SAH - {0xC0C8, 0xC0C8, prH2, gcLo}, // HANGUL SYLLABLE SAE - {0xC0C9, 0xC0E3, prH3, gcLo}, // [27] HANGUL SYLLABLE SAEG..HANGUL SYLLABLE SAEH - {0xC0E4, 0xC0E4, prH2, gcLo}, // HANGUL SYLLABLE SYA - {0xC0E5, 0xC0FF, prH3, gcLo}, // [27] HANGUL SYLLABLE SYAG..HANGUL SYLLABLE SYAH - {0xC100, 0xC100, prH2, gcLo}, // HANGUL SYLLABLE SYAE - {0xC101, 0xC11B, prH3, gcLo}, // [27] HANGUL SYLLABLE SYAEG..HANGUL SYLLABLE SYAEH - {0xC11C, 0xC11C, prH2, gcLo}, // HANGUL SYLLABLE SEO - {0xC11D, 0xC137, prH3, gcLo}, // [27] HANGUL SYLLABLE SEOG..HANGUL SYLLABLE SEOH - {0xC138, 0xC138, prH2, gcLo}, // HANGUL SYLLABLE SE - {0xC139, 0xC153, prH3, gcLo}, // [27] HANGUL SYLLABLE SEG..HANGUL SYLLABLE SEH - {0xC154, 0xC154, prH2, gcLo}, // HANGUL SYLLABLE SYEO - {0xC155, 0xC16F, prH3, gcLo}, // [27] HANGUL SYLLABLE SYEOG..HANGUL SYLLABLE SYEOH - {0xC170, 0xC170, prH2, gcLo}, // HANGUL SYLLABLE SYE - {0xC171, 0xC18B, prH3, gcLo}, // [27] HANGUL SYLLABLE SYEG..HANGUL SYLLABLE SYEH - {0xC18C, 0xC18C, prH2, gcLo}, // HANGUL SYLLABLE SO - {0xC18D, 0xC1A7, prH3, gcLo}, // [27] HANGUL SYLLABLE SOG..HANGUL SYLLABLE SOH - {0xC1A8, 0xC1A8, prH2, gcLo}, // HANGUL SYLLABLE SWA - {0xC1A9, 0xC1C3, prH3, gcLo}, // [27] HANGUL SYLLABLE SWAG..HANGUL SYLLABLE SWAH - {0xC1C4, 0xC1C4, prH2, gcLo}, // HANGUL SYLLABLE SWAE - {0xC1C5, 0xC1DF, prH3, gcLo}, // [27] HANGUL SYLLABLE SWAEG..HANGUL SYLLABLE SWAEH - {0xC1E0, 0xC1E0, prH2, gcLo}, // HANGUL SYLLABLE SOE - {0xC1E1, 0xC1FB, prH3, gcLo}, // [27] HANGUL SYLLABLE SOEG..HANGUL SYLLABLE SOEH - {0xC1FC, 0xC1FC, prH2, gcLo}, // HANGUL SYLLABLE SYO - {0xC1FD, 0xC217, prH3, gcLo}, // [27] HANGUL SYLLABLE SYOG..HANGUL SYLLABLE SYOH - {0xC218, 0xC218, prH2, gcLo}, // HANGUL SYLLABLE SU - {0xC219, 0xC233, prH3, gcLo}, // [27] HANGUL SYLLABLE SUG..HANGUL SYLLABLE SUH - {0xC234, 0xC234, prH2, gcLo}, // HANGUL SYLLABLE SWEO - {0xC235, 0xC24F, prH3, gcLo}, // [27] HANGUL SYLLABLE SWEOG..HANGUL SYLLABLE SWEOH - {0xC250, 0xC250, prH2, gcLo}, // HANGUL SYLLABLE SWE - {0xC251, 0xC26B, prH3, gcLo}, // [27] HANGUL SYLLABLE SWEG..HANGUL SYLLABLE SWEH - {0xC26C, 0xC26C, prH2, gcLo}, // HANGUL SYLLABLE SWI - {0xC26D, 0xC287, prH3, gcLo}, // [27] HANGUL SYLLABLE SWIG..HANGUL SYLLABLE SWIH - {0xC288, 0xC288, prH2, gcLo}, // HANGUL SYLLABLE SYU - {0xC289, 0xC2A3, prH3, gcLo}, // [27] HANGUL SYLLABLE SYUG..HANGUL SYLLABLE SYUH - {0xC2A4, 0xC2A4, prH2, gcLo}, // HANGUL SYLLABLE SEU - {0xC2A5, 0xC2BF, prH3, gcLo}, // [27] HANGUL SYLLABLE SEUG..HANGUL SYLLABLE SEUH - {0xC2C0, 0xC2C0, prH2, gcLo}, // HANGUL SYLLABLE SYI - {0xC2C1, 0xC2DB, prH3, gcLo}, // [27] HANGUL SYLLABLE SYIG..HANGUL SYLLABLE SYIH - {0xC2DC, 0xC2DC, prH2, gcLo}, // HANGUL SYLLABLE SI - {0xC2DD, 0xC2F7, prH3, gcLo}, // [27] HANGUL SYLLABLE SIG..HANGUL SYLLABLE SIH - {0xC2F8, 0xC2F8, prH2, gcLo}, // HANGUL SYLLABLE SSA - {0xC2F9, 0xC313, prH3, gcLo}, // [27] HANGUL SYLLABLE SSAG..HANGUL SYLLABLE SSAH - {0xC314, 0xC314, prH2, gcLo}, // HANGUL SYLLABLE SSAE - {0xC315, 0xC32F, prH3, gcLo}, // [27] HANGUL SYLLABLE SSAEG..HANGUL SYLLABLE SSAEH - {0xC330, 0xC330, prH2, gcLo}, // HANGUL SYLLABLE SSYA - {0xC331, 0xC34B, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYAG..HANGUL SYLLABLE SSYAH - {0xC34C, 0xC34C, prH2, gcLo}, // HANGUL SYLLABLE SSYAE - {0xC34D, 0xC367, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYAEG..HANGUL SYLLABLE SSYAEH - {0xC368, 0xC368, prH2, gcLo}, // HANGUL SYLLABLE SSEO - {0xC369, 0xC383, prH3, gcLo}, // [27] HANGUL SYLLABLE SSEOG..HANGUL SYLLABLE SSEOH - {0xC384, 0xC384, prH2, gcLo}, // HANGUL SYLLABLE SSE - {0xC385, 0xC39F, prH3, gcLo}, // [27] HANGUL SYLLABLE SSEG..HANGUL SYLLABLE SSEH - {0xC3A0, 0xC3A0, prH2, gcLo}, // HANGUL SYLLABLE SSYEO - {0xC3A1, 0xC3BB, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYEOG..HANGUL SYLLABLE SSYEOH - {0xC3BC, 0xC3BC, prH2, gcLo}, // HANGUL SYLLABLE SSYE - {0xC3BD, 0xC3D7, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYEG..HANGUL SYLLABLE SSYEH - {0xC3D8, 0xC3D8, prH2, gcLo}, // HANGUL SYLLABLE SSO - {0xC3D9, 0xC3F3, prH3, gcLo}, // [27] HANGUL SYLLABLE SSOG..HANGUL SYLLABLE SSOH - {0xC3F4, 0xC3F4, prH2, gcLo}, // HANGUL SYLLABLE SSWA - {0xC3F5, 0xC40F, prH3, gcLo}, // [27] HANGUL SYLLABLE SSWAG..HANGUL SYLLABLE SSWAH - {0xC410, 0xC410, prH2, gcLo}, // HANGUL SYLLABLE SSWAE - {0xC411, 0xC42B, prH3, gcLo}, // [27] HANGUL SYLLABLE SSWAEG..HANGUL SYLLABLE SSWAEH - {0xC42C, 0xC42C, prH2, gcLo}, // HANGUL SYLLABLE SSOE - {0xC42D, 0xC447, prH3, gcLo}, // [27] HANGUL SYLLABLE SSOEG..HANGUL SYLLABLE SSOEH - {0xC448, 0xC448, prH2, gcLo}, // HANGUL SYLLABLE SSYO - {0xC449, 0xC463, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYOG..HANGUL SYLLABLE SSYOH - {0xC464, 0xC464, prH2, gcLo}, // HANGUL SYLLABLE SSU - {0xC465, 0xC47F, prH3, gcLo}, // [27] HANGUL SYLLABLE SSUG..HANGUL SYLLABLE SSUH - {0xC480, 0xC480, prH2, gcLo}, // HANGUL SYLLABLE SSWEO - {0xC481, 0xC49B, prH3, gcLo}, // [27] HANGUL SYLLABLE SSWEOG..HANGUL SYLLABLE SSWEOH - {0xC49C, 0xC49C, prH2, gcLo}, // HANGUL SYLLABLE SSWE - {0xC49D, 0xC4B7, prH3, gcLo}, // [27] HANGUL SYLLABLE SSWEG..HANGUL SYLLABLE SSWEH - {0xC4B8, 0xC4B8, prH2, gcLo}, // HANGUL SYLLABLE SSWI - {0xC4B9, 0xC4D3, prH3, gcLo}, // [27] HANGUL SYLLABLE SSWIG..HANGUL SYLLABLE SSWIH - {0xC4D4, 0xC4D4, prH2, gcLo}, // HANGUL SYLLABLE SSYU - {0xC4D5, 0xC4EF, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYUG..HANGUL SYLLABLE SSYUH - {0xC4F0, 0xC4F0, prH2, gcLo}, // HANGUL SYLLABLE SSEU - {0xC4F1, 0xC50B, prH3, gcLo}, // [27] HANGUL SYLLABLE SSEUG..HANGUL SYLLABLE SSEUH - {0xC50C, 0xC50C, prH2, gcLo}, // HANGUL SYLLABLE SSYI - {0xC50D, 0xC527, prH3, gcLo}, // [27] HANGUL SYLLABLE SSYIG..HANGUL SYLLABLE SSYIH - {0xC528, 0xC528, prH2, gcLo}, // HANGUL SYLLABLE SSI - {0xC529, 0xC543, prH3, gcLo}, // [27] HANGUL SYLLABLE SSIG..HANGUL SYLLABLE SSIH - {0xC544, 0xC544, prH2, gcLo}, // HANGUL SYLLABLE A - {0xC545, 0xC55F, prH3, gcLo}, // [27] HANGUL SYLLABLE AG..HANGUL SYLLABLE AH - {0xC560, 0xC560, prH2, gcLo}, // HANGUL SYLLABLE AE - {0xC561, 0xC57B, prH3, gcLo}, // [27] HANGUL SYLLABLE AEG..HANGUL SYLLABLE AEH - {0xC57C, 0xC57C, prH2, gcLo}, // HANGUL SYLLABLE YA - {0xC57D, 0xC597, prH3, gcLo}, // [27] HANGUL SYLLABLE YAG..HANGUL SYLLABLE YAH - {0xC598, 0xC598, prH2, gcLo}, // HANGUL SYLLABLE YAE - {0xC599, 0xC5B3, prH3, gcLo}, // [27] HANGUL SYLLABLE YAEG..HANGUL SYLLABLE YAEH - {0xC5B4, 0xC5B4, prH2, gcLo}, // HANGUL SYLLABLE EO - {0xC5B5, 0xC5CF, prH3, gcLo}, // [27] HANGUL SYLLABLE EOG..HANGUL SYLLABLE EOH - {0xC5D0, 0xC5D0, prH2, gcLo}, // HANGUL SYLLABLE E - {0xC5D1, 0xC5EB, prH3, gcLo}, // [27] HANGUL SYLLABLE EG..HANGUL SYLLABLE EH - {0xC5EC, 0xC5EC, prH2, gcLo}, // HANGUL SYLLABLE YEO - {0xC5ED, 0xC607, prH3, gcLo}, // [27] HANGUL SYLLABLE YEOG..HANGUL SYLLABLE YEOH - {0xC608, 0xC608, prH2, gcLo}, // HANGUL SYLLABLE YE - {0xC609, 0xC623, prH3, gcLo}, // [27] HANGUL SYLLABLE YEG..HANGUL SYLLABLE YEH - {0xC624, 0xC624, prH2, gcLo}, // HANGUL SYLLABLE O - {0xC625, 0xC63F, prH3, gcLo}, // [27] HANGUL SYLLABLE OG..HANGUL SYLLABLE OH - {0xC640, 0xC640, prH2, gcLo}, // HANGUL SYLLABLE WA - {0xC641, 0xC65B, prH3, gcLo}, // [27] HANGUL SYLLABLE WAG..HANGUL SYLLABLE WAH - {0xC65C, 0xC65C, prH2, gcLo}, // HANGUL SYLLABLE WAE - {0xC65D, 0xC677, prH3, gcLo}, // [27] HANGUL SYLLABLE WAEG..HANGUL SYLLABLE WAEH - {0xC678, 0xC678, prH2, gcLo}, // HANGUL SYLLABLE OE - {0xC679, 0xC693, prH3, gcLo}, // [27] HANGUL SYLLABLE OEG..HANGUL SYLLABLE OEH - {0xC694, 0xC694, prH2, gcLo}, // HANGUL SYLLABLE YO - {0xC695, 0xC6AF, prH3, gcLo}, // [27] HANGUL SYLLABLE YOG..HANGUL SYLLABLE YOH - {0xC6B0, 0xC6B0, prH2, gcLo}, // HANGUL SYLLABLE U - {0xC6B1, 0xC6CB, prH3, gcLo}, // [27] HANGUL SYLLABLE UG..HANGUL SYLLABLE UH - {0xC6CC, 0xC6CC, prH2, gcLo}, // HANGUL SYLLABLE WEO - {0xC6CD, 0xC6E7, prH3, gcLo}, // [27] HANGUL SYLLABLE WEOG..HANGUL SYLLABLE WEOH - {0xC6E8, 0xC6E8, prH2, gcLo}, // HANGUL SYLLABLE WE - {0xC6E9, 0xC703, prH3, gcLo}, // [27] HANGUL SYLLABLE WEG..HANGUL SYLLABLE WEH - {0xC704, 0xC704, prH2, gcLo}, // HANGUL SYLLABLE WI - {0xC705, 0xC71F, prH3, gcLo}, // [27] HANGUL SYLLABLE WIG..HANGUL SYLLABLE WIH - {0xC720, 0xC720, prH2, gcLo}, // HANGUL SYLLABLE YU - {0xC721, 0xC73B, prH3, gcLo}, // [27] HANGUL SYLLABLE YUG..HANGUL SYLLABLE YUH - {0xC73C, 0xC73C, prH2, gcLo}, // HANGUL SYLLABLE EU - {0xC73D, 0xC757, prH3, gcLo}, // [27] HANGUL SYLLABLE EUG..HANGUL SYLLABLE EUH - {0xC758, 0xC758, prH2, gcLo}, // HANGUL SYLLABLE YI - {0xC759, 0xC773, prH3, gcLo}, // [27] HANGUL SYLLABLE YIG..HANGUL SYLLABLE YIH - {0xC774, 0xC774, prH2, gcLo}, // HANGUL SYLLABLE I - {0xC775, 0xC78F, prH3, gcLo}, // [27] HANGUL SYLLABLE IG..HANGUL SYLLABLE IH - {0xC790, 0xC790, prH2, gcLo}, // HANGUL SYLLABLE JA - {0xC791, 0xC7AB, prH3, gcLo}, // [27] HANGUL SYLLABLE JAG..HANGUL SYLLABLE JAH - {0xC7AC, 0xC7AC, prH2, gcLo}, // HANGUL SYLLABLE JAE - {0xC7AD, 0xC7C7, prH3, gcLo}, // [27] HANGUL SYLLABLE JAEG..HANGUL SYLLABLE JAEH - {0xC7C8, 0xC7C8, prH2, gcLo}, // HANGUL SYLLABLE JYA - {0xC7C9, 0xC7E3, prH3, gcLo}, // [27] HANGUL SYLLABLE JYAG..HANGUL SYLLABLE JYAH - {0xC7E4, 0xC7E4, prH2, gcLo}, // HANGUL SYLLABLE JYAE - {0xC7E5, 0xC7FF, prH3, gcLo}, // [27] HANGUL SYLLABLE JYAEG..HANGUL SYLLABLE JYAEH - {0xC800, 0xC800, prH2, gcLo}, // HANGUL SYLLABLE JEO - {0xC801, 0xC81B, prH3, gcLo}, // [27] HANGUL SYLLABLE JEOG..HANGUL SYLLABLE JEOH - {0xC81C, 0xC81C, prH2, gcLo}, // HANGUL SYLLABLE JE - {0xC81D, 0xC837, prH3, gcLo}, // [27] HANGUL SYLLABLE JEG..HANGUL SYLLABLE JEH - {0xC838, 0xC838, prH2, gcLo}, // HANGUL SYLLABLE JYEO - {0xC839, 0xC853, prH3, gcLo}, // [27] HANGUL SYLLABLE JYEOG..HANGUL SYLLABLE JYEOH - {0xC854, 0xC854, prH2, gcLo}, // HANGUL SYLLABLE JYE - {0xC855, 0xC86F, prH3, gcLo}, // [27] HANGUL SYLLABLE JYEG..HANGUL SYLLABLE JYEH - {0xC870, 0xC870, prH2, gcLo}, // HANGUL SYLLABLE JO - {0xC871, 0xC88B, prH3, gcLo}, // [27] HANGUL SYLLABLE JOG..HANGUL SYLLABLE JOH - {0xC88C, 0xC88C, prH2, gcLo}, // HANGUL SYLLABLE JWA - {0xC88D, 0xC8A7, prH3, gcLo}, // [27] HANGUL SYLLABLE JWAG..HANGUL SYLLABLE JWAH - {0xC8A8, 0xC8A8, prH2, gcLo}, // HANGUL SYLLABLE JWAE - {0xC8A9, 0xC8C3, prH3, gcLo}, // [27] HANGUL SYLLABLE JWAEG..HANGUL SYLLABLE JWAEH - {0xC8C4, 0xC8C4, prH2, gcLo}, // HANGUL SYLLABLE JOE - {0xC8C5, 0xC8DF, prH3, gcLo}, // [27] HANGUL SYLLABLE JOEG..HANGUL SYLLABLE JOEH - {0xC8E0, 0xC8E0, prH2, gcLo}, // HANGUL SYLLABLE JYO - {0xC8E1, 0xC8FB, prH3, gcLo}, // [27] HANGUL SYLLABLE JYOG..HANGUL SYLLABLE JYOH - {0xC8FC, 0xC8FC, prH2, gcLo}, // HANGUL SYLLABLE JU - {0xC8FD, 0xC917, prH3, gcLo}, // [27] HANGUL SYLLABLE JUG..HANGUL SYLLABLE JUH - {0xC918, 0xC918, prH2, gcLo}, // HANGUL SYLLABLE JWEO - {0xC919, 0xC933, prH3, gcLo}, // [27] HANGUL SYLLABLE JWEOG..HANGUL SYLLABLE JWEOH - {0xC934, 0xC934, prH2, gcLo}, // HANGUL SYLLABLE JWE - {0xC935, 0xC94F, prH3, gcLo}, // [27] HANGUL SYLLABLE JWEG..HANGUL SYLLABLE JWEH - {0xC950, 0xC950, prH2, gcLo}, // HANGUL SYLLABLE JWI - {0xC951, 0xC96B, prH3, gcLo}, // [27] HANGUL SYLLABLE JWIG..HANGUL SYLLABLE JWIH - {0xC96C, 0xC96C, prH2, gcLo}, // HANGUL SYLLABLE JYU - {0xC96D, 0xC987, prH3, gcLo}, // [27] HANGUL SYLLABLE JYUG..HANGUL SYLLABLE JYUH - {0xC988, 0xC988, prH2, gcLo}, // HANGUL SYLLABLE JEU - {0xC989, 0xC9A3, prH3, gcLo}, // [27] HANGUL SYLLABLE JEUG..HANGUL SYLLABLE JEUH - {0xC9A4, 0xC9A4, prH2, gcLo}, // HANGUL SYLLABLE JYI - {0xC9A5, 0xC9BF, prH3, gcLo}, // [27] HANGUL SYLLABLE JYIG..HANGUL SYLLABLE JYIH - {0xC9C0, 0xC9C0, prH2, gcLo}, // HANGUL SYLLABLE JI - {0xC9C1, 0xC9DB, prH3, gcLo}, // [27] HANGUL SYLLABLE JIG..HANGUL SYLLABLE JIH - {0xC9DC, 0xC9DC, prH2, gcLo}, // HANGUL SYLLABLE JJA - {0xC9DD, 0xC9F7, prH3, gcLo}, // [27] HANGUL SYLLABLE JJAG..HANGUL SYLLABLE JJAH - {0xC9F8, 0xC9F8, prH2, gcLo}, // HANGUL SYLLABLE JJAE - {0xC9F9, 0xCA13, prH3, gcLo}, // [27] HANGUL SYLLABLE JJAEG..HANGUL SYLLABLE JJAEH - {0xCA14, 0xCA14, prH2, gcLo}, // HANGUL SYLLABLE JJYA - {0xCA15, 0xCA2F, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYAG..HANGUL SYLLABLE JJYAH - {0xCA30, 0xCA30, prH2, gcLo}, // HANGUL SYLLABLE JJYAE - {0xCA31, 0xCA4B, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYAEG..HANGUL SYLLABLE JJYAEH - {0xCA4C, 0xCA4C, prH2, gcLo}, // HANGUL SYLLABLE JJEO - {0xCA4D, 0xCA67, prH3, gcLo}, // [27] HANGUL SYLLABLE JJEOG..HANGUL SYLLABLE JJEOH - {0xCA68, 0xCA68, prH2, gcLo}, // HANGUL SYLLABLE JJE - {0xCA69, 0xCA83, prH3, gcLo}, // [27] HANGUL SYLLABLE JJEG..HANGUL SYLLABLE JJEH - {0xCA84, 0xCA84, prH2, gcLo}, // HANGUL SYLLABLE JJYEO - {0xCA85, 0xCA9F, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYEOG..HANGUL SYLLABLE JJYEOH - {0xCAA0, 0xCAA0, prH2, gcLo}, // HANGUL SYLLABLE JJYE - {0xCAA1, 0xCABB, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYEG..HANGUL SYLLABLE JJYEH - {0xCABC, 0xCABC, prH2, gcLo}, // HANGUL SYLLABLE JJO - {0xCABD, 0xCAD7, prH3, gcLo}, // [27] HANGUL SYLLABLE JJOG..HANGUL SYLLABLE JJOH - {0xCAD8, 0xCAD8, prH2, gcLo}, // HANGUL SYLLABLE JJWA - {0xCAD9, 0xCAF3, prH3, gcLo}, // [27] HANGUL SYLLABLE JJWAG..HANGUL SYLLABLE JJWAH - {0xCAF4, 0xCAF4, prH2, gcLo}, // HANGUL SYLLABLE JJWAE - {0xCAF5, 0xCB0F, prH3, gcLo}, // [27] HANGUL SYLLABLE JJWAEG..HANGUL SYLLABLE JJWAEH - {0xCB10, 0xCB10, prH2, gcLo}, // HANGUL SYLLABLE JJOE - {0xCB11, 0xCB2B, prH3, gcLo}, // [27] HANGUL SYLLABLE JJOEG..HANGUL SYLLABLE JJOEH - {0xCB2C, 0xCB2C, prH2, gcLo}, // HANGUL SYLLABLE JJYO - {0xCB2D, 0xCB47, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYOG..HANGUL SYLLABLE JJYOH - {0xCB48, 0xCB48, prH2, gcLo}, // HANGUL SYLLABLE JJU - {0xCB49, 0xCB63, prH3, gcLo}, // [27] HANGUL SYLLABLE JJUG..HANGUL SYLLABLE JJUH - {0xCB64, 0xCB64, prH2, gcLo}, // HANGUL SYLLABLE JJWEO - {0xCB65, 0xCB7F, prH3, gcLo}, // [27] HANGUL SYLLABLE JJWEOG..HANGUL SYLLABLE JJWEOH - {0xCB80, 0xCB80, prH2, gcLo}, // HANGUL SYLLABLE JJWE - {0xCB81, 0xCB9B, prH3, gcLo}, // [27] HANGUL SYLLABLE JJWEG..HANGUL SYLLABLE JJWEH - {0xCB9C, 0xCB9C, prH2, gcLo}, // HANGUL SYLLABLE JJWI - {0xCB9D, 0xCBB7, prH3, gcLo}, // [27] HANGUL SYLLABLE JJWIG..HANGUL SYLLABLE JJWIH - {0xCBB8, 0xCBB8, prH2, gcLo}, // HANGUL SYLLABLE JJYU - {0xCBB9, 0xCBD3, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYUG..HANGUL SYLLABLE JJYUH - {0xCBD4, 0xCBD4, prH2, gcLo}, // HANGUL SYLLABLE JJEU - {0xCBD5, 0xCBEF, prH3, gcLo}, // [27] HANGUL SYLLABLE JJEUG..HANGUL SYLLABLE JJEUH - {0xCBF0, 0xCBF0, prH2, gcLo}, // HANGUL SYLLABLE JJYI - {0xCBF1, 0xCC0B, prH3, gcLo}, // [27] HANGUL SYLLABLE JJYIG..HANGUL SYLLABLE JJYIH - {0xCC0C, 0xCC0C, prH2, gcLo}, // HANGUL SYLLABLE JJI - {0xCC0D, 0xCC27, prH3, gcLo}, // [27] HANGUL SYLLABLE JJIG..HANGUL SYLLABLE JJIH - {0xCC28, 0xCC28, prH2, gcLo}, // HANGUL SYLLABLE CA - {0xCC29, 0xCC43, prH3, gcLo}, // [27] HANGUL SYLLABLE CAG..HANGUL SYLLABLE CAH - {0xCC44, 0xCC44, prH2, gcLo}, // HANGUL SYLLABLE CAE - {0xCC45, 0xCC5F, prH3, gcLo}, // [27] HANGUL SYLLABLE CAEG..HANGUL SYLLABLE CAEH - {0xCC60, 0xCC60, prH2, gcLo}, // HANGUL SYLLABLE CYA - {0xCC61, 0xCC7B, prH3, gcLo}, // [27] HANGUL SYLLABLE CYAG..HANGUL SYLLABLE CYAH - {0xCC7C, 0xCC7C, prH2, gcLo}, // HANGUL SYLLABLE CYAE - {0xCC7D, 0xCC97, prH3, gcLo}, // [27] HANGUL SYLLABLE CYAEG..HANGUL SYLLABLE CYAEH - {0xCC98, 0xCC98, prH2, gcLo}, // HANGUL SYLLABLE CEO - {0xCC99, 0xCCB3, prH3, gcLo}, // [27] HANGUL SYLLABLE CEOG..HANGUL SYLLABLE CEOH - {0xCCB4, 0xCCB4, prH2, gcLo}, // HANGUL SYLLABLE CE - {0xCCB5, 0xCCCF, prH3, gcLo}, // [27] HANGUL SYLLABLE CEG..HANGUL SYLLABLE CEH - {0xCCD0, 0xCCD0, prH2, gcLo}, // HANGUL SYLLABLE CYEO - {0xCCD1, 0xCCEB, prH3, gcLo}, // [27] HANGUL SYLLABLE CYEOG..HANGUL SYLLABLE CYEOH - {0xCCEC, 0xCCEC, prH2, gcLo}, // HANGUL SYLLABLE CYE - {0xCCED, 0xCD07, prH3, gcLo}, // [27] HANGUL SYLLABLE CYEG..HANGUL SYLLABLE CYEH - {0xCD08, 0xCD08, prH2, gcLo}, // HANGUL SYLLABLE CO - {0xCD09, 0xCD23, prH3, gcLo}, // [27] HANGUL SYLLABLE COG..HANGUL SYLLABLE COH - {0xCD24, 0xCD24, prH2, gcLo}, // HANGUL SYLLABLE CWA - {0xCD25, 0xCD3F, prH3, gcLo}, // [27] HANGUL SYLLABLE CWAG..HANGUL SYLLABLE CWAH - {0xCD40, 0xCD40, prH2, gcLo}, // HANGUL SYLLABLE CWAE - {0xCD41, 0xCD5B, prH3, gcLo}, // [27] HANGUL SYLLABLE CWAEG..HANGUL SYLLABLE CWAEH - {0xCD5C, 0xCD5C, prH2, gcLo}, // HANGUL SYLLABLE COE - {0xCD5D, 0xCD77, prH3, gcLo}, // [27] HANGUL SYLLABLE COEG..HANGUL SYLLABLE COEH - {0xCD78, 0xCD78, prH2, gcLo}, // HANGUL SYLLABLE CYO - {0xCD79, 0xCD93, prH3, gcLo}, // [27] HANGUL SYLLABLE CYOG..HANGUL SYLLABLE CYOH - {0xCD94, 0xCD94, prH2, gcLo}, // HANGUL SYLLABLE CU - {0xCD95, 0xCDAF, prH3, gcLo}, // [27] HANGUL SYLLABLE CUG..HANGUL SYLLABLE CUH - {0xCDB0, 0xCDB0, prH2, gcLo}, // HANGUL SYLLABLE CWEO - {0xCDB1, 0xCDCB, prH3, gcLo}, // [27] HANGUL SYLLABLE CWEOG..HANGUL SYLLABLE CWEOH - {0xCDCC, 0xCDCC, prH2, gcLo}, // HANGUL SYLLABLE CWE - {0xCDCD, 0xCDE7, prH3, gcLo}, // [27] HANGUL SYLLABLE CWEG..HANGUL SYLLABLE CWEH - {0xCDE8, 0xCDE8, prH2, gcLo}, // HANGUL SYLLABLE CWI - {0xCDE9, 0xCE03, prH3, gcLo}, // [27] HANGUL SYLLABLE CWIG..HANGUL SYLLABLE CWIH - {0xCE04, 0xCE04, prH2, gcLo}, // HANGUL SYLLABLE CYU - {0xCE05, 0xCE1F, prH3, gcLo}, // [27] HANGUL SYLLABLE CYUG..HANGUL SYLLABLE CYUH - {0xCE20, 0xCE20, prH2, gcLo}, // HANGUL SYLLABLE CEU - {0xCE21, 0xCE3B, prH3, gcLo}, // [27] HANGUL SYLLABLE CEUG..HANGUL SYLLABLE CEUH - {0xCE3C, 0xCE3C, prH2, gcLo}, // HANGUL SYLLABLE CYI - {0xCE3D, 0xCE57, prH3, gcLo}, // [27] HANGUL SYLLABLE CYIG..HANGUL SYLLABLE CYIH - {0xCE58, 0xCE58, prH2, gcLo}, // HANGUL SYLLABLE CI - {0xCE59, 0xCE73, prH3, gcLo}, // [27] HANGUL SYLLABLE CIG..HANGUL SYLLABLE CIH - {0xCE74, 0xCE74, prH2, gcLo}, // HANGUL SYLLABLE KA - {0xCE75, 0xCE8F, prH3, gcLo}, // [27] HANGUL SYLLABLE KAG..HANGUL SYLLABLE KAH - {0xCE90, 0xCE90, prH2, gcLo}, // HANGUL SYLLABLE KAE - {0xCE91, 0xCEAB, prH3, gcLo}, // [27] HANGUL SYLLABLE KAEG..HANGUL SYLLABLE KAEH - {0xCEAC, 0xCEAC, prH2, gcLo}, // HANGUL SYLLABLE KYA - {0xCEAD, 0xCEC7, prH3, gcLo}, // [27] HANGUL SYLLABLE KYAG..HANGUL SYLLABLE KYAH - {0xCEC8, 0xCEC8, prH2, gcLo}, // HANGUL SYLLABLE KYAE - {0xCEC9, 0xCEE3, prH3, gcLo}, // [27] HANGUL SYLLABLE KYAEG..HANGUL SYLLABLE KYAEH - {0xCEE4, 0xCEE4, prH2, gcLo}, // HANGUL SYLLABLE KEO - {0xCEE5, 0xCEFF, prH3, gcLo}, // [27] HANGUL SYLLABLE KEOG..HANGUL SYLLABLE KEOH - {0xCF00, 0xCF00, prH2, gcLo}, // HANGUL SYLLABLE KE - {0xCF01, 0xCF1B, prH3, gcLo}, // [27] HANGUL SYLLABLE KEG..HANGUL SYLLABLE KEH - {0xCF1C, 0xCF1C, prH2, gcLo}, // HANGUL SYLLABLE KYEO - {0xCF1D, 0xCF37, prH3, gcLo}, // [27] HANGUL SYLLABLE KYEOG..HANGUL SYLLABLE KYEOH - {0xCF38, 0xCF38, prH2, gcLo}, // HANGUL SYLLABLE KYE - {0xCF39, 0xCF53, prH3, gcLo}, // [27] HANGUL SYLLABLE KYEG..HANGUL SYLLABLE KYEH - {0xCF54, 0xCF54, prH2, gcLo}, // HANGUL SYLLABLE KO - {0xCF55, 0xCF6F, prH3, gcLo}, // [27] HANGUL SYLLABLE KOG..HANGUL SYLLABLE KOH - {0xCF70, 0xCF70, prH2, gcLo}, // HANGUL SYLLABLE KWA - {0xCF71, 0xCF8B, prH3, gcLo}, // [27] HANGUL SYLLABLE KWAG..HANGUL SYLLABLE KWAH - {0xCF8C, 0xCF8C, prH2, gcLo}, // HANGUL SYLLABLE KWAE - {0xCF8D, 0xCFA7, prH3, gcLo}, // [27] HANGUL SYLLABLE KWAEG..HANGUL SYLLABLE KWAEH - {0xCFA8, 0xCFA8, prH2, gcLo}, // HANGUL SYLLABLE KOE - {0xCFA9, 0xCFC3, prH3, gcLo}, // [27] HANGUL SYLLABLE KOEG..HANGUL SYLLABLE KOEH - {0xCFC4, 0xCFC4, prH2, gcLo}, // HANGUL SYLLABLE KYO - {0xCFC5, 0xCFDF, prH3, gcLo}, // [27] HANGUL SYLLABLE KYOG..HANGUL SYLLABLE KYOH - {0xCFE0, 0xCFE0, prH2, gcLo}, // HANGUL SYLLABLE KU - {0xCFE1, 0xCFFB, prH3, gcLo}, // [27] HANGUL SYLLABLE KUG..HANGUL SYLLABLE KUH - {0xCFFC, 0xCFFC, prH2, gcLo}, // HANGUL SYLLABLE KWEO - {0xCFFD, 0xD017, prH3, gcLo}, // [27] HANGUL SYLLABLE KWEOG..HANGUL SYLLABLE KWEOH - {0xD018, 0xD018, prH2, gcLo}, // HANGUL SYLLABLE KWE - {0xD019, 0xD033, prH3, gcLo}, // [27] HANGUL SYLLABLE KWEG..HANGUL SYLLABLE KWEH - {0xD034, 0xD034, prH2, gcLo}, // HANGUL SYLLABLE KWI - {0xD035, 0xD04F, prH3, gcLo}, // [27] HANGUL SYLLABLE KWIG..HANGUL SYLLABLE KWIH - {0xD050, 0xD050, prH2, gcLo}, // HANGUL SYLLABLE KYU - {0xD051, 0xD06B, prH3, gcLo}, // [27] HANGUL SYLLABLE KYUG..HANGUL SYLLABLE KYUH - {0xD06C, 0xD06C, prH2, gcLo}, // HANGUL SYLLABLE KEU - {0xD06D, 0xD087, prH3, gcLo}, // [27] HANGUL SYLLABLE KEUG..HANGUL SYLLABLE KEUH - {0xD088, 0xD088, prH2, gcLo}, // HANGUL SYLLABLE KYI - {0xD089, 0xD0A3, prH3, gcLo}, // [27] HANGUL SYLLABLE KYIG..HANGUL SYLLABLE KYIH - {0xD0A4, 0xD0A4, prH2, gcLo}, // HANGUL SYLLABLE KI - {0xD0A5, 0xD0BF, prH3, gcLo}, // [27] HANGUL SYLLABLE KIG..HANGUL SYLLABLE KIH - {0xD0C0, 0xD0C0, prH2, gcLo}, // HANGUL SYLLABLE TA - {0xD0C1, 0xD0DB, prH3, gcLo}, // [27] HANGUL SYLLABLE TAG..HANGUL SYLLABLE TAH - {0xD0DC, 0xD0DC, prH2, gcLo}, // HANGUL SYLLABLE TAE - {0xD0DD, 0xD0F7, prH3, gcLo}, // [27] HANGUL SYLLABLE TAEG..HANGUL SYLLABLE TAEH - {0xD0F8, 0xD0F8, prH2, gcLo}, // HANGUL SYLLABLE TYA - {0xD0F9, 0xD113, prH3, gcLo}, // [27] HANGUL SYLLABLE TYAG..HANGUL SYLLABLE TYAH - {0xD114, 0xD114, prH2, gcLo}, // HANGUL SYLLABLE TYAE - {0xD115, 0xD12F, prH3, gcLo}, // [27] HANGUL SYLLABLE TYAEG..HANGUL SYLLABLE TYAEH - {0xD130, 0xD130, prH2, gcLo}, // HANGUL SYLLABLE TEO - {0xD131, 0xD14B, prH3, gcLo}, // [27] HANGUL SYLLABLE TEOG..HANGUL SYLLABLE TEOH - {0xD14C, 0xD14C, prH2, gcLo}, // HANGUL SYLLABLE TE - {0xD14D, 0xD167, prH3, gcLo}, // [27] HANGUL SYLLABLE TEG..HANGUL SYLLABLE TEH - {0xD168, 0xD168, prH2, gcLo}, // HANGUL SYLLABLE TYEO - {0xD169, 0xD183, prH3, gcLo}, // [27] HANGUL SYLLABLE TYEOG..HANGUL SYLLABLE TYEOH - {0xD184, 0xD184, prH2, gcLo}, // HANGUL SYLLABLE TYE - {0xD185, 0xD19F, prH3, gcLo}, // [27] HANGUL SYLLABLE TYEG..HANGUL SYLLABLE TYEH - {0xD1A0, 0xD1A0, prH2, gcLo}, // HANGUL SYLLABLE TO - {0xD1A1, 0xD1BB, prH3, gcLo}, // [27] HANGUL SYLLABLE TOG..HANGUL SYLLABLE TOH - {0xD1BC, 0xD1BC, prH2, gcLo}, // HANGUL SYLLABLE TWA - {0xD1BD, 0xD1D7, prH3, gcLo}, // [27] HANGUL SYLLABLE TWAG..HANGUL SYLLABLE TWAH - {0xD1D8, 0xD1D8, prH2, gcLo}, // HANGUL SYLLABLE TWAE - {0xD1D9, 0xD1F3, prH3, gcLo}, // [27] HANGUL SYLLABLE TWAEG..HANGUL SYLLABLE TWAEH - {0xD1F4, 0xD1F4, prH2, gcLo}, // HANGUL SYLLABLE TOE - {0xD1F5, 0xD20F, prH3, gcLo}, // [27] HANGUL SYLLABLE TOEG..HANGUL SYLLABLE TOEH - {0xD210, 0xD210, prH2, gcLo}, // HANGUL SYLLABLE TYO - {0xD211, 0xD22B, prH3, gcLo}, // [27] HANGUL SYLLABLE TYOG..HANGUL SYLLABLE TYOH - {0xD22C, 0xD22C, prH2, gcLo}, // HANGUL SYLLABLE TU - {0xD22D, 0xD247, prH3, gcLo}, // [27] HANGUL SYLLABLE TUG..HANGUL SYLLABLE TUH - {0xD248, 0xD248, prH2, gcLo}, // HANGUL SYLLABLE TWEO - {0xD249, 0xD263, prH3, gcLo}, // [27] HANGUL SYLLABLE TWEOG..HANGUL SYLLABLE TWEOH - {0xD264, 0xD264, prH2, gcLo}, // HANGUL SYLLABLE TWE - {0xD265, 0xD27F, prH3, gcLo}, // [27] HANGUL SYLLABLE TWEG..HANGUL SYLLABLE TWEH - {0xD280, 0xD280, prH2, gcLo}, // HANGUL SYLLABLE TWI - {0xD281, 0xD29B, prH3, gcLo}, // [27] HANGUL SYLLABLE TWIG..HANGUL SYLLABLE TWIH - {0xD29C, 0xD29C, prH2, gcLo}, // HANGUL SYLLABLE TYU - {0xD29D, 0xD2B7, prH3, gcLo}, // [27] HANGUL SYLLABLE TYUG..HANGUL SYLLABLE TYUH - {0xD2B8, 0xD2B8, prH2, gcLo}, // HANGUL SYLLABLE TEU - {0xD2B9, 0xD2D3, prH3, gcLo}, // [27] HANGUL SYLLABLE TEUG..HANGUL SYLLABLE TEUH - {0xD2D4, 0xD2D4, prH2, gcLo}, // HANGUL SYLLABLE TYI - {0xD2D5, 0xD2EF, prH3, gcLo}, // [27] HANGUL SYLLABLE TYIG..HANGUL SYLLABLE TYIH - {0xD2F0, 0xD2F0, prH2, gcLo}, // HANGUL SYLLABLE TI - {0xD2F1, 0xD30B, prH3, gcLo}, // [27] HANGUL SYLLABLE TIG..HANGUL SYLLABLE TIH - {0xD30C, 0xD30C, prH2, gcLo}, // HANGUL SYLLABLE PA - {0xD30D, 0xD327, prH3, gcLo}, // [27] HANGUL SYLLABLE PAG..HANGUL SYLLABLE PAH - {0xD328, 0xD328, prH2, gcLo}, // HANGUL SYLLABLE PAE - {0xD329, 0xD343, prH3, gcLo}, // [27] HANGUL SYLLABLE PAEG..HANGUL SYLLABLE PAEH - {0xD344, 0xD344, prH2, gcLo}, // HANGUL SYLLABLE PYA - {0xD345, 0xD35F, prH3, gcLo}, // [27] HANGUL SYLLABLE PYAG..HANGUL SYLLABLE PYAH - {0xD360, 0xD360, prH2, gcLo}, // HANGUL SYLLABLE PYAE - {0xD361, 0xD37B, prH3, gcLo}, // [27] HANGUL SYLLABLE PYAEG..HANGUL SYLLABLE PYAEH - {0xD37C, 0xD37C, prH2, gcLo}, // HANGUL SYLLABLE PEO - {0xD37D, 0xD397, prH3, gcLo}, // [27] HANGUL SYLLABLE PEOG..HANGUL SYLLABLE PEOH - {0xD398, 0xD398, prH2, gcLo}, // HANGUL SYLLABLE PE - {0xD399, 0xD3B3, prH3, gcLo}, // [27] HANGUL SYLLABLE PEG..HANGUL SYLLABLE PEH - {0xD3B4, 0xD3B4, prH2, gcLo}, // HANGUL SYLLABLE PYEO - {0xD3B5, 0xD3CF, prH3, gcLo}, // [27] HANGUL SYLLABLE PYEOG..HANGUL SYLLABLE PYEOH - {0xD3D0, 0xD3D0, prH2, gcLo}, // HANGUL SYLLABLE PYE - {0xD3D1, 0xD3EB, prH3, gcLo}, // [27] HANGUL SYLLABLE PYEG..HANGUL SYLLABLE PYEH - {0xD3EC, 0xD3EC, prH2, gcLo}, // HANGUL SYLLABLE PO - {0xD3ED, 0xD407, prH3, gcLo}, // [27] HANGUL SYLLABLE POG..HANGUL SYLLABLE POH - {0xD408, 0xD408, prH2, gcLo}, // HANGUL SYLLABLE PWA - {0xD409, 0xD423, prH3, gcLo}, // [27] HANGUL SYLLABLE PWAG..HANGUL SYLLABLE PWAH - {0xD424, 0xD424, prH2, gcLo}, // HANGUL SYLLABLE PWAE - {0xD425, 0xD43F, prH3, gcLo}, // [27] HANGUL SYLLABLE PWAEG..HANGUL SYLLABLE PWAEH - {0xD440, 0xD440, prH2, gcLo}, // HANGUL SYLLABLE POE - {0xD441, 0xD45B, prH3, gcLo}, // [27] HANGUL SYLLABLE POEG..HANGUL SYLLABLE POEH - {0xD45C, 0xD45C, prH2, gcLo}, // HANGUL SYLLABLE PYO - {0xD45D, 0xD477, prH3, gcLo}, // [27] HANGUL SYLLABLE PYOG..HANGUL SYLLABLE PYOH - {0xD478, 0xD478, prH2, gcLo}, // HANGUL SYLLABLE PU - {0xD479, 0xD493, prH3, gcLo}, // [27] HANGUL SYLLABLE PUG..HANGUL SYLLABLE PUH - {0xD494, 0xD494, prH2, gcLo}, // HANGUL SYLLABLE PWEO - {0xD495, 0xD4AF, prH3, gcLo}, // [27] HANGUL SYLLABLE PWEOG..HANGUL SYLLABLE PWEOH - {0xD4B0, 0xD4B0, prH2, gcLo}, // HANGUL SYLLABLE PWE - {0xD4B1, 0xD4CB, prH3, gcLo}, // [27] HANGUL SYLLABLE PWEG..HANGUL SYLLABLE PWEH - {0xD4CC, 0xD4CC, prH2, gcLo}, // HANGUL SYLLABLE PWI - {0xD4CD, 0xD4E7, prH3, gcLo}, // [27] HANGUL SYLLABLE PWIG..HANGUL SYLLABLE PWIH - {0xD4E8, 0xD4E8, prH2, gcLo}, // HANGUL SYLLABLE PYU - {0xD4E9, 0xD503, prH3, gcLo}, // [27] HANGUL SYLLABLE PYUG..HANGUL SYLLABLE PYUH - {0xD504, 0xD504, prH2, gcLo}, // HANGUL SYLLABLE PEU - {0xD505, 0xD51F, prH3, gcLo}, // [27] HANGUL SYLLABLE PEUG..HANGUL SYLLABLE PEUH - {0xD520, 0xD520, prH2, gcLo}, // HANGUL SYLLABLE PYI - {0xD521, 0xD53B, prH3, gcLo}, // [27] HANGUL SYLLABLE PYIG..HANGUL SYLLABLE PYIH - {0xD53C, 0xD53C, prH2, gcLo}, // HANGUL SYLLABLE PI - {0xD53D, 0xD557, prH3, gcLo}, // [27] HANGUL SYLLABLE PIG..HANGUL SYLLABLE PIH - {0xD558, 0xD558, prH2, gcLo}, // HANGUL SYLLABLE HA - {0xD559, 0xD573, prH3, gcLo}, // [27] HANGUL SYLLABLE HAG..HANGUL SYLLABLE HAH - {0xD574, 0xD574, prH2, gcLo}, // HANGUL SYLLABLE HAE - {0xD575, 0xD58F, prH3, gcLo}, // [27] HANGUL SYLLABLE HAEG..HANGUL SYLLABLE HAEH - {0xD590, 0xD590, prH2, gcLo}, // HANGUL SYLLABLE HYA - {0xD591, 0xD5AB, prH3, gcLo}, // [27] HANGUL SYLLABLE HYAG..HANGUL SYLLABLE HYAH - {0xD5AC, 0xD5AC, prH2, gcLo}, // HANGUL SYLLABLE HYAE - {0xD5AD, 0xD5C7, prH3, gcLo}, // [27] HANGUL SYLLABLE HYAEG..HANGUL SYLLABLE HYAEH - {0xD5C8, 0xD5C8, prH2, gcLo}, // HANGUL SYLLABLE HEO - {0xD5C9, 0xD5E3, prH3, gcLo}, // [27] HANGUL SYLLABLE HEOG..HANGUL SYLLABLE HEOH - {0xD5E4, 0xD5E4, prH2, gcLo}, // HANGUL SYLLABLE HE - {0xD5E5, 0xD5FF, prH3, gcLo}, // [27] HANGUL SYLLABLE HEG..HANGUL SYLLABLE HEH - {0xD600, 0xD600, prH2, gcLo}, // HANGUL SYLLABLE HYEO - {0xD601, 0xD61B, prH3, gcLo}, // [27] HANGUL SYLLABLE HYEOG..HANGUL SYLLABLE HYEOH - {0xD61C, 0xD61C, prH2, gcLo}, // HANGUL SYLLABLE HYE - {0xD61D, 0xD637, prH3, gcLo}, // [27] HANGUL SYLLABLE HYEG..HANGUL SYLLABLE HYEH - {0xD638, 0xD638, prH2, gcLo}, // HANGUL SYLLABLE HO - {0xD639, 0xD653, prH3, gcLo}, // [27] HANGUL SYLLABLE HOG..HANGUL SYLLABLE HOH - {0xD654, 0xD654, prH2, gcLo}, // HANGUL SYLLABLE HWA - {0xD655, 0xD66F, prH3, gcLo}, // [27] HANGUL SYLLABLE HWAG..HANGUL SYLLABLE HWAH - {0xD670, 0xD670, prH2, gcLo}, // HANGUL SYLLABLE HWAE - {0xD671, 0xD68B, prH3, gcLo}, // [27] HANGUL SYLLABLE HWAEG..HANGUL SYLLABLE HWAEH - {0xD68C, 0xD68C, prH2, gcLo}, // HANGUL SYLLABLE HOE - {0xD68D, 0xD6A7, prH3, gcLo}, // [27] HANGUL SYLLABLE HOEG..HANGUL SYLLABLE HOEH - {0xD6A8, 0xD6A8, prH2, gcLo}, // HANGUL SYLLABLE HYO - {0xD6A9, 0xD6C3, prH3, gcLo}, // [27] HANGUL SYLLABLE HYOG..HANGUL SYLLABLE HYOH - {0xD6C4, 0xD6C4, prH2, gcLo}, // HANGUL SYLLABLE HU - {0xD6C5, 0xD6DF, prH3, gcLo}, // [27] HANGUL SYLLABLE HUG..HANGUL SYLLABLE HUH - {0xD6E0, 0xD6E0, prH2, gcLo}, // HANGUL SYLLABLE HWEO - {0xD6E1, 0xD6FB, prH3, gcLo}, // [27] HANGUL SYLLABLE HWEOG..HANGUL SYLLABLE HWEOH - {0xD6FC, 0xD6FC, prH2, gcLo}, // HANGUL SYLLABLE HWE - {0xD6FD, 0xD717, prH3, gcLo}, // [27] HANGUL SYLLABLE HWEG..HANGUL SYLLABLE HWEH - {0xD718, 0xD718, prH2, gcLo}, // HANGUL SYLLABLE HWI - {0xD719, 0xD733, prH3, gcLo}, // [27] HANGUL SYLLABLE HWIG..HANGUL SYLLABLE HWIH - {0xD734, 0xD734, prH2, gcLo}, // HANGUL SYLLABLE HYU - {0xD735, 0xD74F, prH3, gcLo}, // [27] HANGUL SYLLABLE HYUG..HANGUL SYLLABLE HYUH - {0xD750, 0xD750, prH2, gcLo}, // HANGUL SYLLABLE HEU - {0xD751, 0xD76B, prH3, gcLo}, // [27] HANGUL SYLLABLE HEUG..HANGUL SYLLABLE HEUH - {0xD76C, 0xD76C, prH2, gcLo}, // HANGUL SYLLABLE HYI - {0xD76D, 0xD787, prH3, gcLo}, // [27] HANGUL SYLLABLE HYIG..HANGUL SYLLABLE HYIH - {0xD788, 0xD788, prH2, gcLo}, // HANGUL SYLLABLE HI - {0xD789, 0xD7A3, prH3, gcLo}, // [27] HANGUL SYLLABLE HIG..HANGUL SYLLABLE HIH - {0xD7B0, 0xD7C6, prJV, gcLo}, // [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E - {0xD7CB, 0xD7FB, prJT, gcLo}, // [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH - {0xD800, 0xDB7F, prSG, gcCs}, // [896] .. - {0xDB80, 0xDBFF, prSG, gcCs}, // [128] .. - {0xDC00, 0xDFFF, prSG, gcCs}, // [1024] .. - {0xE000, 0xF8FF, prXX, gcCo}, // [6400] .. - {0xF900, 0xFA6D, prID, gcLo}, // [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D - {0xFA6E, 0xFA6F, prID, gcCn}, // [2] .. - {0xFA70, 0xFAD9, prID, gcLo}, // [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9 - {0xFADA, 0xFAFF, prID, gcCn}, // [38] .. - {0xFB00, 0xFB06, prAL, gcLl}, // [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST - {0xFB13, 0xFB17, prAL, gcLl}, // [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH - {0xFB1D, 0xFB1D, prHL, gcLo}, // HEBREW LETTER YOD WITH HIRIQ - {0xFB1E, 0xFB1E, prCM, gcMn}, // HEBREW POINT JUDEO-SPANISH VARIKA - {0xFB1F, 0xFB28, prHL, gcLo}, // [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV - {0xFB29, 0xFB29, prAL, gcSm}, // HEBREW LETTER ALTERNATIVE PLUS SIGN - {0xFB2A, 0xFB36, prHL, gcLo}, // [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH - {0xFB38, 0xFB3C, prHL, gcLo}, // [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH - {0xFB3E, 0xFB3E, prHL, gcLo}, // HEBREW LETTER MEM WITH DAGESH - {0xFB40, 0xFB41, prHL, gcLo}, // [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH - {0xFB43, 0xFB44, prHL, gcLo}, // [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH - {0xFB46, 0xFB4F, prHL, gcLo}, // [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED - {0xFB50, 0xFBB1, prAL, gcLo}, // [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM - {0xFBB2, 0xFBC2, prAL, gcSk}, // [17] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL WASLA ABOVE - {0xFBD3, 0xFD3D, prAL, gcLo}, // [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM - {0xFD3E, 0xFD3E, prCL, gcPe}, // ORNATE LEFT PARENTHESIS - {0xFD3F, 0xFD3F, prOP, gcPs}, // ORNATE RIGHT PARENTHESIS - {0xFD40, 0xFD4F, prAL, gcSo}, // [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH - {0xFD50, 0xFD8F, prAL, gcLo}, // [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM - {0xFD92, 0xFDC7, prAL, gcLo}, // [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM - {0xFDCF, 0xFDCF, prAL, gcSo}, // ARABIC LIGATURE SALAAMUHU ALAYNAA - {0xFDF0, 0xFDFB, prAL, gcLo}, // [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU - {0xFDFC, 0xFDFC, prPO, gcSc}, // RIAL SIGN - {0xFDFD, 0xFDFF, prAL, gcSo}, // [3] ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM..ARABIC LIGATURE AZZA WA JALL - {0xFE00, 0xFE0F, prCM, gcMn}, // [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16 - {0xFE10, 0xFE10, prIS, gcPo}, // PRESENTATION FORM FOR VERTICAL COMMA - {0xFE11, 0xFE12, prCL, gcPo}, // [2] PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA..PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC FULL STOP - {0xFE13, 0xFE14, prIS, gcPo}, // [2] PRESENTATION FORM FOR VERTICAL COLON..PRESENTATION FORM FOR VERTICAL SEMICOLON - {0xFE15, 0xFE16, prEX, gcPo}, // [2] PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK..PRESENTATION FORM FOR VERTICAL QUESTION MARK - {0xFE17, 0xFE17, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET - {0xFE18, 0xFE18, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET - {0xFE19, 0xFE19, prIN, gcPo}, // PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS - {0xFE20, 0xFE2F, prCM, gcMn}, // [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF - {0xFE30, 0xFE30, prID, gcPo}, // PRESENTATION FORM FOR VERTICAL TWO DOT LEADER - {0xFE31, 0xFE32, prID, gcPd}, // [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH - {0xFE33, 0xFE34, prID, gcPc}, // [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE - {0xFE35, 0xFE35, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS - {0xFE36, 0xFE36, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS - {0xFE37, 0xFE37, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET - {0xFE38, 0xFE38, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET - {0xFE39, 0xFE39, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET - {0xFE3A, 0xFE3A, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET - {0xFE3B, 0xFE3B, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET - {0xFE3C, 0xFE3C, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET - {0xFE3D, 0xFE3D, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET - {0xFE3E, 0xFE3E, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET - {0xFE3F, 0xFE3F, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET - {0xFE40, 0xFE40, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET - {0xFE41, 0xFE41, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET - {0xFE42, 0xFE42, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET - {0xFE43, 0xFE43, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET - {0xFE44, 0xFE44, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET - {0xFE45, 0xFE46, prID, gcPo}, // [2] SESAME DOT..WHITE SESAME DOT - {0xFE47, 0xFE47, prOP, gcPs}, // PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET - {0xFE48, 0xFE48, prCL, gcPe}, // PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET - {0xFE49, 0xFE4C, prID, gcPo}, // [4] DASHED OVERLINE..DOUBLE WAVY OVERLINE - {0xFE4D, 0xFE4F, prID, gcPc}, // [3] DASHED LOW LINE..WAVY LOW LINE - {0xFE50, 0xFE50, prCL, gcPo}, // SMALL COMMA - {0xFE51, 0xFE51, prID, gcPo}, // SMALL IDEOGRAPHIC COMMA - {0xFE52, 0xFE52, prCL, gcPo}, // SMALL FULL STOP - {0xFE54, 0xFE55, prNS, gcPo}, // [2] SMALL SEMICOLON..SMALL COLON - {0xFE56, 0xFE57, prEX, gcPo}, // [2] SMALL QUESTION MARK..SMALL EXCLAMATION MARK - {0xFE58, 0xFE58, prID, gcPd}, // SMALL EM DASH - {0xFE59, 0xFE59, prOP, gcPs}, // SMALL LEFT PARENTHESIS - {0xFE5A, 0xFE5A, prCL, gcPe}, // SMALL RIGHT PARENTHESIS - {0xFE5B, 0xFE5B, prOP, gcPs}, // SMALL LEFT CURLY BRACKET - {0xFE5C, 0xFE5C, prCL, gcPe}, // SMALL RIGHT CURLY BRACKET - {0xFE5D, 0xFE5D, prOP, gcPs}, // SMALL LEFT TORTOISE SHELL BRACKET - {0xFE5E, 0xFE5E, prCL, gcPe}, // SMALL RIGHT TORTOISE SHELL BRACKET - {0xFE5F, 0xFE61, prID, gcPo}, // [3] SMALL NUMBER SIGN..SMALL ASTERISK - {0xFE62, 0xFE62, prID, gcSm}, // SMALL PLUS SIGN - {0xFE63, 0xFE63, prID, gcPd}, // SMALL HYPHEN-MINUS - {0xFE64, 0xFE66, prID, gcSm}, // [3] SMALL LESS-THAN SIGN..SMALL EQUALS SIGN - {0xFE68, 0xFE68, prID, gcPo}, // SMALL REVERSE SOLIDUS - {0xFE69, 0xFE69, prPR, gcSc}, // SMALL DOLLAR SIGN - {0xFE6A, 0xFE6A, prPO, gcPo}, // SMALL PERCENT SIGN - {0xFE6B, 0xFE6B, prID, gcPo}, // SMALL COMMERCIAL AT - {0xFE70, 0xFE74, prAL, gcLo}, // [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM - {0xFE76, 0xFEFC, prAL, gcLo}, // [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM - {0xFEFF, 0xFEFF, prWJ, gcCf}, // ZERO WIDTH NO-BREAK SPACE - {0xFF01, 0xFF01, prEX, gcPo}, // FULLWIDTH EXCLAMATION MARK - {0xFF02, 0xFF03, prID, gcPo}, // [2] FULLWIDTH QUOTATION MARK..FULLWIDTH NUMBER SIGN - {0xFF04, 0xFF04, prPR, gcSc}, // FULLWIDTH DOLLAR SIGN - {0xFF05, 0xFF05, prPO, gcPo}, // FULLWIDTH PERCENT SIGN - {0xFF06, 0xFF07, prID, gcPo}, // [2] FULLWIDTH AMPERSAND..FULLWIDTH APOSTROPHE - {0xFF08, 0xFF08, prOP, gcPs}, // FULLWIDTH LEFT PARENTHESIS - {0xFF09, 0xFF09, prCL, gcPe}, // FULLWIDTH RIGHT PARENTHESIS - {0xFF0A, 0xFF0A, prID, gcPo}, // FULLWIDTH ASTERISK - {0xFF0B, 0xFF0B, prID, gcSm}, // FULLWIDTH PLUS SIGN - {0xFF0C, 0xFF0C, prCL, gcPo}, // FULLWIDTH COMMA - {0xFF0D, 0xFF0D, prID, gcPd}, // FULLWIDTH HYPHEN-MINUS - {0xFF0E, 0xFF0E, prCL, gcPo}, // FULLWIDTH FULL STOP - {0xFF0F, 0xFF0F, prID, gcPo}, // FULLWIDTH SOLIDUS - {0xFF10, 0xFF19, prID, gcNd}, // [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE - {0xFF1A, 0xFF1B, prNS, gcPo}, // [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON - {0xFF1C, 0xFF1E, prID, gcSm}, // [3] FULLWIDTH LESS-THAN SIGN..FULLWIDTH GREATER-THAN SIGN - {0xFF1F, 0xFF1F, prEX, gcPo}, // FULLWIDTH QUESTION MARK - {0xFF20, 0xFF20, prID, gcPo}, // FULLWIDTH COMMERCIAL AT - {0xFF21, 0xFF3A, prID, gcLu}, // [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z - {0xFF3B, 0xFF3B, prOP, gcPs}, // FULLWIDTH LEFT SQUARE BRACKET - {0xFF3C, 0xFF3C, prID, gcPo}, // FULLWIDTH REVERSE SOLIDUS - {0xFF3D, 0xFF3D, prCL, gcPe}, // FULLWIDTH RIGHT SQUARE BRACKET - {0xFF3E, 0xFF3E, prID, gcSk}, // FULLWIDTH CIRCUMFLEX ACCENT - {0xFF3F, 0xFF3F, prID, gcPc}, // FULLWIDTH LOW LINE - {0xFF40, 0xFF40, prID, gcSk}, // FULLWIDTH GRAVE ACCENT - {0xFF41, 0xFF5A, prID, gcLl}, // [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z - {0xFF5B, 0xFF5B, prOP, gcPs}, // FULLWIDTH LEFT CURLY BRACKET - {0xFF5C, 0xFF5C, prID, gcSm}, // FULLWIDTH VERTICAL LINE - {0xFF5D, 0xFF5D, prCL, gcPe}, // FULLWIDTH RIGHT CURLY BRACKET - {0xFF5E, 0xFF5E, prID, gcSm}, // FULLWIDTH TILDE - {0xFF5F, 0xFF5F, prOP, gcPs}, // FULLWIDTH LEFT WHITE PARENTHESIS - {0xFF60, 0xFF60, prCL, gcPe}, // FULLWIDTH RIGHT WHITE PARENTHESIS - {0xFF61, 0xFF61, prCL, gcPo}, // HALFWIDTH IDEOGRAPHIC FULL STOP - {0xFF62, 0xFF62, prOP, gcPs}, // HALFWIDTH LEFT CORNER BRACKET - {0xFF63, 0xFF63, prCL, gcPe}, // HALFWIDTH RIGHT CORNER BRACKET - {0xFF64, 0xFF64, prCL, gcPo}, // HALFWIDTH IDEOGRAPHIC COMMA - {0xFF65, 0xFF65, prNS, gcPo}, // HALFWIDTH KATAKANA MIDDLE DOT - {0xFF66, 0xFF66, prID, gcLo}, // HALFWIDTH KATAKANA LETTER WO - {0xFF67, 0xFF6F, prCJ, gcLo}, // [9] HALFWIDTH KATAKANA LETTER SMALL A..HALFWIDTH KATAKANA LETTER SMALL TU - {0xFF70, 0xFF70, prCJ, gcLm}, // HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK - {0xFF71, 0xFF9D, prID, gcLo}, // [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N - {0xFF9E, 0xFF9F, prNS, gcLm}, // [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK - {0xFFA0, 0xFFBE, prID, gcLo}, // [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH - {0xFFC2, 0xFFC7, prID, gcLo}, // [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E - {0xFFCA, 0xFFCF, prID, gcLo}, // [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE - {0xFFD2, 0xFFD7, prID, gcLo}, // [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU - {0xFFDA, 0xFFDC, prID, gcLo}, // [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I - {0xFFE0, 0xFFE0, prPO, gcSc}, // FULLWIDTH CENT SIGN - {0xFFE1, 0xFFE1, prPR, gcSc}, // FULLWIDTH POUND SIGN - {0xFFE2, 0xFFE2, prID, gcSm}, // FULLWIDTH NOT SIGN - {0xFFE3, 0xFFE3, prID, gcSk}, // FULLWIDTH MACRON - {0xFFE4, 0xFFE4, prID, gcSo}, // FULLWIDTH BROKEN BAR - {0xFFE5, 0xFFE6, prPR, gcSc}, // [2] FULLWIDTH YEN SIGN..FULLWIDTH WON SIGN - {0xFFE8, 0xFFE8, prAL, gcSo}, // HALFWIDTH FORMS LIGHT VERTICAL - {0xFFE9, 0xFFEC, prAL, gcSm}, // [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW - {0xFFED, 0xFFEE, prAL, gcSo}, // [2] HALFWIDTH BLACK SQUARE..HALFWIDTH WHITE CIRCLE - {0xFFF9, 0xFFFB, prCM, gcCf}, // [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR - {0xFFFC, 0xFFFC, prCB, gcSo}, // OBJECT REPLACEMENT CHARACTER - {0xFFFD, 0xFFFD, prAI, gcSo}, // REPLACEMENT CHARACTER - {0x10000, 0x1000B, prAL, gcLo}, // [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE - {0x1000D, 0x10026, prAL, gcLo}, // [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO - {0x10028, 0x1003A, prAL, gcLo}, // [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO - {0x1003C, 0x1003D, prAL, gcLo}, // [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE - {0x1003F, 0x1004D, prAL, gcLo}, // [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO - {0x10050, 0x1005D, prAL, gcLo}, // [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089 - {0x10080, 0x100FA, prAL, gcLo}, // [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305 - {0x10100, 0x10102, prBA, gcPo}, // [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK - {0x10107, 0x10133, prAL, gcNo}, // [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND - {0x10137, 0x1013F, prAL, gcSo}, // [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT - {0x10140, 0x10174, prAL, gcNl}, // [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS - {0x10175, 0x10178, prAL, gcNo}, // [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN - {0x10179, 0x10189, prAL, gcSo}, // [17] GREEK YEAR SIGN..GREEK TRYBLION BASE SIGN - {0x1018A, 0x1018B, prAL, gcNo}, // [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN - {0x1018C, 0x1018E, prAL, gcSo}, // [3] GREEK SINUSOID SIGN..NOMISMA SIGN - {0x10190, 0x1019C, prAL, gcSo}, // [13] ROMAN SEXTANS SIGN..ASCIA SYMBOL - {0x101A0, 0x101A0, prAL, gcSo}, // GREEK SYMBOL TAU RHO - {0x101D0, 0x101FC, prAL, gcSo}, // [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND - {0x101FD, 0x101FD, prCM, gcMn}, // PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE - {0x10280, 0x1029C, prAL, gcLo}, // [29] LYCIAN LETTER A..LYCIAN LETTER X - {0x102A0, 0x102D0, prAL, gcLo}, // [49] CARIAN LETTER A..CARIAN LETTER UUU3 - {0x102E0, 0x102E0, prCM, gcMn}, // COPTIC EPACT THOUSANDS MARK - {0x102E1, 0x102FB, prAL, gcNo}, // [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED - {0x10300, 0x1031F, prAL, gcLo}, // [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS - {0x10320, 0x10323, prAL, gcNo}, // [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY - {0x1032D, 0x1032F, prAL, gcLo}, // [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE - {0x10330, 0x10340, prAL, gcLo}, // [17] GOTHIC LETTER AHSA..GOTHIC LETTER PAIRTHRA - {0x10341, 0x10341, prAL, gcNl}, // GOTHIC LETTER NINETY - {0x10342, 0x10349, prAL, gcLo}, // [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL - {0x1034A, 0x1034A, prAL, gcNl}, // GOTHIC LETTER NINE HUNDRED - {0x10350, 0x10375, prAL, gcLo}, // [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA - {0x10376, 0x1037A, prCM, gcMn}, // [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII - {0x10380, 0x1039D, prAL, gcLo}, // [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU - {0x1039F, 0x1039F, prBA, gcPo}, // UGARITIC WORD DIVIDER - {0x103A0, 0x103C3, prAL, gcLo}, // [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA - {0x103C8, 0x103CF, prAL, gcLo}, // [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH - {0x103D0, 0x103D0, prBA, gcPo}, // OLD PERSIAN WORD DIVIDER - {0x103D1, 0x103D5, prAL, gcNl}, // [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED - {0x10400, 0x1044F, prAL, gcLC}, // [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW - {0x10450, 0x1047F, prAL, gcLo}, // [48] SHAVIAN LETTER PEEP..SHAVIAN LETTER YEW - {0x10480, 0x1049D, prAL, gcLo}, // [30] OSMANYA LETTER ALEF..OSMANYA LETTER OO - {0x104A0, 0x104A9, prNU, gcNd}, // [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE - {0x104B0, 0x104D3, prAL, gcLu}, // [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA - {0x104D8, 0x104FB, prAL, gcLl}, // [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA - {0x10500, 0x10527, prAL, gcLo}, // [40] ELBASAN LETTER A..ELBASAN LETTER KHE - {0x10530, 0x10563, prAL, gcLo}, // [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW - {0x1056F, 0x1056F, prAL, gcPo}, // CAUCASIAN ALBANIAN CITATION MARK - {0x10570, 0x1057A, prAL, gcLu}, // [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA - {0x1057C, 0x1058A, prAL, gcLu}, // [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE - {0x1058C, 0x10592, prAL, gcLu}, // [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE - {0x10594, 0x10595, prAL, gcLu}, // [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE - {0x10597, 0x105A1, prAL, gcLl}, // [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA - {0x105A3, 0x105B1, prAL, gcLl}, // [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE - {0x105B3, 0x105B9, prAL, gcLl}, // [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE - {0x105BB, 0x105BC, prAL, gcLl}, // [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE - {0x10600, 0x10736, prAL, gcLo}, // [311] LINEAR A SIGN AB001..LINEAR A SIGN A664 - {0x10740, 0x10755, prAL, gcLo}, // [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE - {0x10760, 0x10767, prAL, gcLo}, // [8] LINEAR A SIGN A800..LINEAR A SIGN A807 - {0x10780, 0x10785, prAL, gcLm}, // [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK - {0x10787, 0x107B0, prAL, gcLm}, // [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK - {0x107B2, 0x107BA, prAL, gcLm}, // [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL - {0x10800, 0x10805, prAL, gcLo}, // [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA - {0x10808, 0x10808, prAL, gcLo}, // CYPRIOT SYLLABLE JO - {0x1080A, 0x10835, prAL, gcLo}, // [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO - {0x10837, 0x10838, prAL, gcLo}, // [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE - {0x1083C, 0x1083C, prAL, gcLo}, // CYPRIOT SYLLABLE ZA - {0x1083F, 0x1083F, prAL, gcLo}, // CYPRIOT SYLLABLE ZO - {0x10840, 0x10855, prAL, gcLo}, // [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW - {0x10857, 0x10857, prBA, gcPo}, // IMPERIAL ARAMAIC SECTION SIGN - {0x10858, 0x1085F, prAL, gcNo}, // [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND - {0x10860, 0x10876, prAL, gcLo}, // [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW - {0x10877, 0x10878, prAL, gcSo}, // [2] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE RIGHT-POINTING FLEURON - {0x10879, 0x1087F, prAL, gcNo}, // [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY - {0x10880, 0x1089E, prAL, gcLo}, // [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW - {0x108A7, 0x108AF, prAL, gcNo}, // [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED - {0x108E0, 0x108F2, prAL, gcLo}, // [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH - {0x108F4, 0x108F5, prAL, gcLo}, // [2] HATRAN LETTER SHIN..HATRAN LETTER TAW - {0x108FB, 0x108FF, prAL, gcNo}, // [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED - {0x10900, 0x10915, prAL, gcLo}, // [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU - {0x10916, 0x1091B, prAL, gcNo}, // [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE - {0x1091F, 0x1091F, prBA, gcPo}, // PHOENICIAN WORD SEPARATOR - {0x10920, 0x10939, prAL, gcLo}, // [26] LYDIAN LETTER A..LYDIAN LETTER C - {0x1093F, 0x1093F, prAL, gcPo}, // LYDIAN TRIANGULAR MARK - {0x10980, 0x1099F, prAL, gcLo}, // [32] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC HIEROGLYPHIC SYMBOL VIDJ-2 - {0x109A0, 0x109B7, prAL, gcLo}, // [24] MEROITIC CURSIVE LETTER A..MEROITIC CURSIVE LETTER DA - {0x109BC, 0x109BD, prAL, gcNo}, // [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF - {0x109BE, 0x109BF, prAL, gcLo}, // [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN - {0x109C0, 0x109CF, prAL, gcNo}, // [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY - {0x109D2, 0x109FF, prAL, gcNo}, // [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS - {0x10A00, 0x10A00, prAL, gcLo}, // KHAROSHTHI LETTER A - {0x10A01, 0x10A03, prCM, gcMn}, // [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R - {0x10A05, 0x10A06, prCM, gcMn}, // [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O - {0x10A0C, 0x10A0F, prCM, gcMn}, // [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA - {0x10A10, 0x10A13, prAL, gcLo}, // [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA - {0x10A15, 0x10A17, prAL, gcLo}, // [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA - {0x10A19, 0x10A35, prAL, gcLo}, // [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA - {0x10A38, 0x10A3A, prCM, gcMn}, // [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW - {0x10A3F, 0x10A3F, prCM, gcMn}, // KHAROSHTHI VIRAMA - {0x10A40, 0x10A48, prAL, gcNo}, // [9] KHAROSHTHI DIGIT ONE..KHAROSHTHI FRACTION ONE HALF - {0x10A50, 0x10A57, prBA, gcPo}, // [8] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION DOUBLE DANDA - {0x10A58, 0x10A58, prAL, gcPo}, // KHAROSHTHI PUNCTUATION LINES - {0x10A60, 0x10A7C, prAL, gcLo}, // [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH - {0x10A7D, 0x10A7E, prAL, gcNo}, // [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY - {0x10A7F, 0x10A7F, prAL, gcPo}, // OLD SOUTH ARABIAN NUMERIC INDICATOR - {0x10A80, 0x10A9C, prAL, gcLo}, // [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH - {0x10A9D, 0x10A9F, prAL, gcNo}, // [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY - {0x10AC0, 0x10AC7, prAL, gcLo}, // [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW - {0x10AC8, 0x10AC8, prAL, gcSo}, // MANICHAEAN SIGN UD - {0x10AC9, 0x10AE4, prAL, gcLo}, // [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW - {0x10AE5, 0x10AE6, prCM, gcMn}, // [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW - {0x10AEB, 0x10AEF, prAL, gcNo}, // [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED - {0x10AF0, 0x10AF5, prBA, gcPo}, // [6] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION TWO DOTS - {0x10AF6, 0x10AF6, prIN, gcPo}, // MANICHAEAN PUNCTUATION LINE FILLER - {0x10B00, 0x10B35, prAL, gcLo}, // [54] AVESTAN LETTER A..AVESTAN LETTER HE - {0x10B39, 0x10B3F, prBA, gcPo}, // [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION - {0x10B40, 0x10B55, prAL, gcLo}, // [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW - {0x10B58, 0x10B5F, prAL, gcNo}, // [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND - {0x10B60, 0x10B72, prAL, gcLo}, // [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW - {0x10B78, 0x10B7F, prAL, gcNo}, // [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND - {0x10B80, 0x10B91, prAL, gcLo}, // [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW - {0x10B99, 0x10B9C, prAL, gcPo}, // [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT - {0x10BA9, 0x10BAF, prAL, gcNo}, // [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED - {0x10C00, 0x10C48, prAL, gcLo}, // [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH - {0x10C80, 0x10CB2, prAL, gcLu}, // [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US - {0x10CC0, 0x10CF2, prAL, gcLl}, // [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US - {0x10CFA, 0x10CFF, prAL, gcNo}, // [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND - {0x10D00, 0x10D23, prAL, gcLo}, // [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA - {0x10D24, 0x10D27, prCM, gcMn}, // [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI - {0x10D30, 0x10D39, prNU, gcNd}, // [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE - {0x10E60, 0x10E7E, prAL, gcNo}, // [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS - {0x10E80, 0x10EA9, prAL, gcLo}, // [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET - {0x10EAB, 0x10EAC, prCM, gcMn}, // [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK - {0x10EAD, 0x10EAD, prBA, gcPd}, // YEZIDI HYPHENATION MARK - {0x10EB0, 0x10EB1, prAL, gcLo}, // [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE - {0x10EFD, 0x10EFF, prCM, gcMn}, // [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA - {0x10F00, 0x10F1C, prAL, gcLo}, // [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL - {0x10F1D, 0x10F26, prAL, gcNo}, // [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF - {0x10F27, 0x10F27, prAL, gcLo}, // OLD SOGDIAN LIGATURE AYIN-DALETH - {0x10F30, 0x10F45, prAL, gcLo}, // [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN - {0x10F46, 0x10F50, prCM, gcMn}, // [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW - {0x10F51, 0x10F54, prAL, gcNo}, // [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED - {0x10F55, 0x10F59, prAL, gcPo}, // [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT - {0x10F70, 0x10F81, prAL, gcLo}, // [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH - {0x10F82, 0x10F85, prCM, gcMn}, // [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW - {0x10F86, 0x10F89, prAL, gcPo}, // [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS - {0x10FB0, 0x10FC4, prAL, gcLo}, // [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW - {0x10FC5, 0x10FCB, prAL, gcNo}, // [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED - {0x10FE0, 0x10FF6, prAL, gcLo}, // [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH - {0x11000, 0x11000, prCM, gcMc}, // BRAHMI SIGN CANDRABINDU - {0x11001, 0x11001, prCM, gcMn}, // BRAHMI SIGN ANUSVARA - {0x11002, 0x11002, prCM, gcMc}, // BRAHMI SIGN VISARGA - {0x11003, 0x11037, prAL, gcLo}, // [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA - {0x11038, 0x11046, prCM, gcMn}, // [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA - {0x11047, 0x11048, prBA, gcPo}, // [2] BRAHMI DANDA..BRAHMI DOUBLE DANDA - {0x11049, 0x1104D, prAL, gcPo}, // [5] BRAHMI PUNCTUATION DOT..BRAHMI PUNCTUATION LOTUS - {0x11052, 0x11065, prAL, gcNo}, // [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND - {0x11066, 0x1106F, prNU, gcNd}, // [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE - {0x11070, 0x11070, prCM, gcMn}, // BRAHMI SIGN OLD TAMIL VIRAMA - {0x11071, 0x11072, prAL, gcLo}, // [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O - {0x11073, 0x11074, prCM, gcMn}, // [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O - {0x11075, 0x11075, prAL, gcLo}, // BRAHMI LETTER OLD TAMIL LLA - {0x1107F, 0x1107F, prCM, gcMn}, // BRAHMI NUMBER JOINER - {0x11080, 0x11081, prCM, gcMn}, // [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA - {0x11082, 0x11082, prCM, gcMc}, // KAITHI SIGN VISARGA - {0x11083, 0x110AF, prAL, gcLo}, // [45] KAITHI LETTER A..KAITHI LETTER HA - {0x110B0, 0x110B2, prCM, gcMc}, // [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II - {0x110B3, 0x110B6, prCM, gcMn}, // [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI - {0x110B7, 0x110B8, prCM, gcMc}, // [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU - {0x110B9, 0x110BA, prCM, gcMn}, // [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA - {0x110BB, 0x110BC, prAL, gcPo}, // [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN - {0x110BD, 0x110BD, prAL, gcCf}, // KAITHI NUMBER SIGN - {0x110BE, 0x110C1, prBA, gcPo}, // [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA - {0x110C2, 0x110C2, prCM, gcMn}, // KAITHI VOWEL SIGN VOCALIC R - {0x110CD, 0x110CD, prAL, gcCf}, // KAITHI NUMBER SIGN ABOVE - {0x110D0, 0x110E8, prAL, gcLo}, // [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE - {0x110F0, 0x110F9, prNU, gcNd}, // [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE - {0x11100, 0x11102, prCM, gcMn}, // [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA - {0x11103, 0x11126, prAL, gcLo}, // [36] CHAKMA LETTER AA..CHAKMA LETTER HAA - {0x11127, 0x1112B, prCM, gcMn}, // [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU - {0x1112C, 0x1112C, prCM, gcMc}, // CHAKMA VOWEL SIGN E - {0x1112D, 0x11134, prCM, gcMn}, // [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA - {0x11136, 0x1113F, prNU, gcNd}, // [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE - {0x11140, 0x11143, prBA, gcPo}, // [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK - {0x11144, 0x11144, prAL, gcLo}, // CHAKMA LETTER LHAA - {0x11145, 0x11146, prCM, gcMc}, // [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI - {0x11147, 0x11147, prAL, gcLo}, // CHAKMA LETTER VAA - {0x11150, 0x11172, prAL, gcLo}, // [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA - {0x11173, 0x11173, prCM, gcMn}, // MAHAJANI SIGN NUKTA - {0x11174, 0x11174, prAL, gcPo}, // MAHAJANI ABBREVIATION SIGN - {0x11175, 0x11175, prBB, gcPo}, // MAHAJANI SECTION MARK - {0x11176, 0x11176, prAL, gcLo}, // MAHAJANI LIGATURE SHRI - {0x11180, 0x11181, prCM, gcMn}, // [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA - {0x11182, 0x11182, prCM, gcMc}, // SHARADA SIGN VISARGA - {0x11183, 0x111B2, prAL, gcLo}, // [48] SHARADA LETTER A..SHARADA LETTER HA - {0x111B3, 0x111B5, prCM, gcMc}, // [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II - {0x111B6, 0x111BE, prCM, gcMn}, // [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O - {0x111BF, 0x111C0, prCM, gcMc}, // [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA - {0x111C1, 0x111C4, prAL, gcLo}, // [4] SHARADA SIGN AVAGRAHA..SHARADA OM - {0x111C5, 0x111C6, prBA, gcPo}, // [2] SHARADA DANDA..SHARADA DOUBLE DANDA - {0x111C7, 0x111C7, prAL, gcPo}, // SHARADA ABBREVIATION SIGN - {0x111C8, 0x111C8, prBA, gcPo}, // SHARADA SEPARATOR - {0x111C9, 0x111CC, prCM, gcMn}, // [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK - {0x111CD, 0x111CD, prAL, gcPo}, // SHARADA SUTRA MARK - {0x111CE, 0x111CE, prCM, gcMc}, // SHARADA VOWEL SIGN PRISHTHAMATRA E - {0x111CF, 0x111CF, prCM, gcMn}, // SHARADA SIGN INVERTED CANDRABINDU - {0x111D0, 0x111D9, prNU, gcNd}, // [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE - {0x111DA, 0x111DA, prAL, gcLo}, // SHARADA EKAM - {0x111DB, 0x111DB, prBB, gcPo}, // SHARADA SIGN SIDDHAM - {0x111DC, 0x111DC, prAL, gcLo}, // SHARADA HEADSTROKE - {0x111DD, 0x111DF, prBA, gcPo}, // [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2 - {0x111E1, 0x111F4, prAL, gcNo}, // [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND - {0x11200, 0x11211, prAL, gcLo}, // [18] KHOJKI LETTER A..KHOJKI LETTER JJA - {0x11213, 0x1122B, prAL, gcLo}, // [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA - {0x1122C, 0x1122E, prCM, gcMc}, // [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II - {0x1122F, 0x11231, prCM, gcMn}, // [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI - {0x11232, 0x11233, prCM, gcMc}, // [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU - {0x11234, 0x11234, prCM, gcMn}, // KHOJKI SIGN ANUSVARA - {0x11235, 0x11235, prCM, gcMc}, // KHOJKI SIGN VIRAMA - {0x11236, 0x11237, prCM, gcMn}, // [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA - {0x11238, 0x11239, prBA, gcPo}, // [2] KHOJKI DANDA..KHOJKI DOUBLE DANDA - {0x1123A, 0x1123A, prAL, gcPo}, // KHOJKI WORD SEPARATOR - {0x1123B, 0x1123C, prBA, gcPo}, // [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK - {0x1123D, 0x1123D, prAL, gcPo}, // KHOJKI ABBREVIATION SIGN - {0x1123E, 0x1123E, prCM, gcMn}, // KHOJKI SIGN SUKUN - {0x1123F, 0x11240, prAL, gcLo}, // [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I - {0x11241, 0x11241, prCM, gcMn}, // KHOJKI VOWEL SIGN VOCALIC R - {0x11280, 0x11286, prAL, gcLo}, // [7] MULTANI LETTER A..MULTANI LETTER GA - {0x11288, 0x11288, prAL, gcLo}, // MULTANI LETTER GHA - {0x1128A, 0x1128D, prAL, gcLo}, // [4] MULTANI LETTER CA..MULTANI LETTER JJA - {0x1128F, 0x1129D, prAL, gcLo}, // [15] MULTANI LETTER NYA..MULTANI LETTER BA - {0x1129F, 0x112A8, prAL, gcLo}, // [10] MULTANI LETTER BHA..MULTANI LETTER RHA - {0x112A9, 0x112A9, prBA, gcPo}, // MULTANI SECTION MARK - {0x112B0, 0x112DE, prAL, gcLo}, // [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA - {0x112DF, 0x112DF, prCM, gcMn}, // KHUDAWADI SIGN ANUSVARA - {0x112E0, 0x112E2, prCM, gcMc}, // [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II - {0x112E3, 0x112EA, prCM, gcMn}, // [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA - {0x112F0, 0x112F9, prNU, gcNd}, // [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE - {0x11300, 0x11301, prCM, gcMn}, // [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU - {0x11302, 0x11303, prCM, gcMc}, // [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA - {0x11305, 0x1130C, prAL, gcLo}, // [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L - {0x1130F, 0x11310, prAL, gcLo}, // [2] GRANTHA LETTER EE..GRANTHA LETTER AI - {0x11313, 0x11328, prAL, gcLo}, // [22] GRANTHA LETTER OO..GRANTHA LETTER NA - {0x1132A, 0x11330, prAL, gcLo}, // [7] GRANTHA LETTER PA..GRANTHA LETTER RA - {0x11332, 0x11333, prAL, gcLo}, // [2] GRANTHA LETTER LA..GRANTHA LETTER LLA - {0x11335, 0x11339, prAL, gcLo}, // [5] GRANTHA LETTER VA..GRANTHA LETTER HA - {0x1133B, 0x1133C, prCM, gcMn}, // [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA - {0x1133D, 0x1133D, prAL, gcLo}, // GRANTHA SIGN AVAGRAHA - {0x1133E, 0x1133F, prCM, gcMc}, // [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I - {0x11340, 0x11340, prCM, gcMn}, // GRANTHA VOWEL SIGN II - {0x11341, 0x11344, prCM, gcMc}, // [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR - {0x11347, 0x11348, prCM, gcMc}, // [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI - {0x1134B, 0x1134D, prCM, gcMc}, // [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA - {0x11350, 0x11350, prAL, gcLo}, // GRANTHA OM - {0x11357, 0x11357, prCM, gcMc}, // GRANTHA AU LENGTH MARK - {0x1135D, 0x11361, prAL, gcLo}, // [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL - {0x11362, 0x11363, prCM, gcMc}, // [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL - {0x11366, 0x1136C, prCM, gcMn}, // [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX - {0x11370, 0x11374, prCM, gcMn}, // [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA - {0x11400, 0x11434, prAL, gcLo}, // [53] NEWA LETTER A..NEWA LETTER HA - {0x11435, 0x11437, prCM, gcMc}, // [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II - {0x11438, 0x1143F, prCM, gcMn}, // [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI - {0x11440, 0x11441, prCM, gcMc}, // [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU - {0x11442, 0x11444, prCM, gcMn}, // [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA - {0x11445, 0x11445, prCM, gcMc}, // NEWA SIGN VISARGA - {0x11446, 0x11446, prCM, gcMn}, // NEWA SIGN NUKTA - {0x11447, 0x1144A, prAL, gcLo}, // [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI - {0x1144B, 0x1144E, prBA, gcPo}, // [4] NEWA DANDA..NEWA GAP FILLER - {0x1144F, 0x1144F, prAL, gcPo}, // NEWA ABBREVIATION SIGN - {0x11450, 0x11459, prNU, gcNd}, // [10] NEWA DIGIT ZERO..NEWA DIGIT NINE - {0x1145A, 0x1145B, prBA, gcPo}, // [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK - {0x1145D, 0x1145D, prAL, gcPo}, // NEWA INSERTION SIGN - {0x1145E, 0x1145E, prCM, gcMn}, // NEWA SANDHI MARK - {0x1145F, 0x11461, prAL, gcLo}, // [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA - {0x11480, 0x114AF, prAL, gcLo}, // [48] TIRHUTA ANJI..TIRHUTA LETTER HA - {0x114B0, 0x114B2, prCM, gcMc}, // [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II - {0x114B3, 0x114B8, prCM, gcMn}, // [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL - {0x114B9, 0x114B9, prCM, gcMc}, // TIRHUTA VOWEL SIGN E - {0x114BA, 0x114BA, prCM, gcMn}, // TIRHUTA VOWEL SIGN SHORT E - {0x114BB, 0x114BE, prCM, gcMc}, // [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU - {0x114BF, 0x114C0, prCM, gcMn}, // [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA - {0x114C1, 0x114C1, prCM, gcMc}, // TIRHUTA SIGN VISARGA - {0x114C2, 0x114C3, prCM, gcMn}, // [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA - {0x114C4, 0x114C5, prAL, gcLo}, // [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG - {0x114C6, 0x114C6, prAL, gcPo}, // TIRHUTA ABBREVIATION SIGN - {0x114C7, 0x114C7, prAL, gcLo}, // TIRHUTA OM - {0x114D0, 0x114D9, prNU, gcNd}, // [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE - {0x11580, 0x115AE, prAL, gcLo}, // [47] SIDDHAM LETTER A..SIDDHAM LETTER HA - {0x115AF, 0x115B1, prCM, gcMc}, // [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II - {0x115B2, 0x115B5, prCM, gcMn}, // [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR - {0x115B8, 0x115BB, prCM, gcMc}, // [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU - {0x115BC, 0x115BD, prCM, gcMn}, // [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA - {0x115BE, 0x115BE, prCM, gcMc}, // SIDDHAM SIGN VISARGA - {0x115BF, 0x115C0, prCM, gcMn}, // [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA - {0x115C1, 0x115C1, prBB, gcPo}, // SIDDHAM SIGN SIDDHAM - {0x115C2, 0x115C3, prBA, gcPo}, // [2] SIDDHAM DANDA..SIDDHAM DOUBLE DANDA - {0x115C4, 0x115C5, prEX, gcPo}, // [2] SIDDHAM SEPARATOR DOT..SIDDHAM SEPARATOR BAR - {0x115C6, 0x115C8, prAL, gcPo}, // [3] SIDDHAM REPETITION MARK-1..SIDDHAM REPETITION MARK-3 - {0x115C9, 0x115D7, prBA, gcPo}, // [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES - {0x115D8, 0x115DB, prAL, gcLo}, // [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U - {0x115DC, 0x115DD, prCM, gcMn}, // [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU - {0x11600, 0x1162F, prAL, gcLo}, // [48] MODI LETTER A..MODI LETTER LLA - {0x11630, 0x11632, prCM, gcMc}, // [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II - {0x11633, 0x1163A, prCM, gcMn}, // [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI - {0x1163B, 0x1163C, prCM, gcMc}, // [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU - {0x1163D, 0x1163D, prCM, gcMn}, // MODI SIGN ANUSVARA - {0x1163E, 0x1163E, prCM, gcMc}, // MODI SIGN VISARGA - {0x1163F, 0x11640, prCM, gcMn}, // [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA - {0x11641, 0x11642, prBA, gcPo}, // [2] MODI DANDA..MODI DOUBLE DANDA - {0x11643, 0x11643, prAL, gcPo}, // MODI ABBREVIATION SIGN - {0x11644, 0x11644, prAL, gcLo}, // MODI SIGN HUVA - {0x11650, 0x11659, prNU, gcNd}, // [10] MODI DIGIT ZERO..MODI DIGIT NINE - {0x11660, 0x1166C, prBB, gcPo}, // [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT - {0x11680, 0x116AA, prAL, gcLo}, // [43] TAKRI LETTER A..TAKRI LETTER RRA - {0x116AB, 0x116AB, prCM, gcMn}, // TAKRI SIGN ANUSVARA - {0x116AC, 0x116AC, prCM, gcMc}, // TAKRI SIGN VISARGA - {0x116AD, 0x116AD, prCM, gcMn}, // TAKRI VOWEL SIGN AA - {0x116AE, 0x116AF, prCM, gcMc}, // [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II - {0x116B0, 0x116B5, prCM, gcMn}, // [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU - {0x116B6, 0x116B6, prCM, gcMc}, // TAKRI SIGN VIRAMA - {0x116B7, 0x116B7, prCM, gcMn}, // TAKRI SIGN NUKTA - {0x116B8, 0x116B8, prAL, gcLo}, // TAKRI LETTER ARCHAIC KHA - {0x116B9, 0x116B9, prAL, gcPo}, // TAKRI ABBREVIATION SIGN - {0x116C0, 0x116C9, prNU, gcNd}, // [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE - {0x11700, 0x1171A, prSA, gcLo}, // [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA - {0x1171D, 0x1171F, prSA, gcMn}, // [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA - {0x11720, 0x11721, prSA, gcMc}, // [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA - {0x11722, 0x11725, prSA, gcMn}, // [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU - {0x11726, 0x11726, prSA, gcMc}, // AHOM VOWEL SIGN E - {0x11727, 0x1172B, prSA, gcMn}, // [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER - {0x11730, 0x11739, prNU, gcNd}, // [10] AHOM DIGIT ZERO..AHOM DIGIT NINE - {0x1173A, 0x1173B, prSA, gcNo}, // [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY - {0x1173C, 0x1173E, prBA, gcPo}, // [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI - {0x1173F, 0x1173F, prSA, gcSo}, // AHOM SYMBOL VI - {0x11740, 0x11746, prSA, gcLo}, // [7] AHOM LETTER CA..AHOM LETTER LLA - {0x11800, 0x1182B, prAL, gcLo}, // [44] DOGRA LETTER A..DOGRA LETTER RRA - {0x1182C, 0x1182E, prCM, gcMc}, // [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II - {0x1182F, 0x11837, prCM, gcMn}, // [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA - {0x11838, 0x11838, prCM, gcMc}, // DOGRA SIGN VISARGA - {0x11839, 0x1183A, prCM, gcMn}, // [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA - {0x1183B, 0x1183B, prAL, gcPo}, // DOGRA ABBREVIATION SIGN - {0x118A0, 0x118DF, prAL, gcLC}, // [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO - {0x118E0, 0x118E9, prNU, gcNd}, // [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE - {0x118EA, 0x118F2, prAL, gcNo}, // [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY - {0x118FF, 0x118FF, prAL, gcLo}, // WARANG CITI OM - {0x11900, 0x11906, prAL, gcLo}, // [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E - {0x11909, 0x11909, prAL, gcLo}, // DIVES AKURU LETTER O - {0x1190C, 0x11913, prAL, gcLo}, // [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA - {0x11915, 0x11916, prAL, gcLo}, // [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA - {0x11918, 0x1192F, prAL, gcLo}, // [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA - {0x11930, 0x11935, prCM, gcMc}, // [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E - {0x11937, 0x11938, prCM, gcMc}, // [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O - {0x1193B, 0x1193C, prCM, gcMn}, // [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU - {0x1193D, 0x1193D, prCM, gcMc}, // DIVES AKURU SIGN HALANTA - {0x1193E, 0x1193E, prCM, gcMn}, // DIVES AKURU VIRAMA - {0x1193F, 0x1193F, prAL, gcLo}, // DIVES AKURU PREFIXED NASAL SIGN - {0x11940, 0x11940, prCM, gcMc}, // DIVES AKURU MEDIAL YA - {0x11941, 0x11941, prAL, gcLo}, // DIVES AKURU INITIAL RA - {0x11942, 0x11942, prCM, gcMc}, // DIVES AKURU MEDIAL RA - {0x11943, 0x11943, prCM, gcMn}, // DIVES AKURU SIGN NUKTA - {0x11944, 0x11946, prBA, gcPo}, // [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK - {0x11950, 0x11959, prNU, gcNd}, // [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE - {0x119A0, 0x119A7, prAL, gcLo}, // [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR - {0x119AA, 0x119D0, prAL, gcLo}, // [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA - {0x119D1, 0x119D3, prCM, gcMc}, // [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II - {0x119D4, 0x119D7, prCM, gcMn}, // [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR - {0x119DA, 0x119DB, prCM, gcMn}, // [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI - {0x119DC, 0x119DF, prCM, gcMc}, // [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA - {0x119E0, 0x119E0, prCM, gcMn}, // NANDINAGARI SIGN VIRAMA - {0x119E1, 0x119E1, prAL, gcLo}, // NANDINAGARI SIGN AVAGRAHA - {0x119E2, 0x119E2, prBB, gcPo}, // NANDINAGARI SIGN SIDDHAM - {0x119E3, 0x119E3, prAL, gcLo}, // NANDINAGARI HEADSTROKE - {0x119E4, 0x119E4, prCM, gcMc}, // NANDINAGARI VOWEL SIGN PRISHTHAMATRA E - {0x11A00, 0x11A00, prAL, gcLo}, // ZANABAZAR SQUARE LETTER A - {0x11A01, 0x11A0A, prCM, gcMn}, // [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK - {0x11A0B, 0x11A32, prAL, gcLo}, // [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA - {0x11A33, 0x11A38, prCM, gcMn}, // [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA - {0x11A39, 0x11A39, prCM, gcMc}, // ZANABAZAR SQUARE SIGN VISARGA - {0x11A3A, 0x11A3A, prAL, gcLo}, // ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA - {0x11A3B, 0x11A3E, prCM, gcMn}, // [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA - {0x11A3F, 0x11A3F, prBB, gcPo}, // ZANABAZAR SQUARE INITIAL HEAD MARK - {0x11A40, 0x11A40, prAL, gcPo}, // ZANABAZAR SQUARE CLOSING HEAD MARK - {0x11A41, 0x11A44, prBA, gcPo}, // [4] ZANABAZAR SQUARE MARK TSHEG..ZANABAZAR SQUARE MARK LONG TSHEG - {0x11A45, 0x11A45, prBB, gcPo}, // ZANABAZAR SQUARE INITIAL DOUBLE-LINED HEAD MARK - {0x11A46, 0x11A46, prAL, gcPo}, // ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK - {0x11A47, 0x11A47, prCM, gcMn}, // ZANABAZAR SQUARE SUBJOINER - {0x11A50, 0x11A50, prAL, gcLo}, // SOYOMBO LETTER A - {0x11A51, 0x11A56, prCM, gcMn}, // [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE - {0x11A57, 0x11A58, prCM, gcMc}, // [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU - {0x11A59, 0x11A5B, prCM, gcMn}, // [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK - {0x11A5C, 0x11A89, prAL, gcLo}, // [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA - {0x11A8A, 0x11A96, prCM, gcMn}, // [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA - {0x11A97, 0x11A97, prCM, gcMc}, // SOYOMBO SIGN VISARGA - {0x11A98, 0x11A99, prCM, gcMn}, // [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER - {0x11A9A, 0x11A9C, prBA, gcPo}, // [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD - {0x11A9D, 0x11A9D, prAL, gcLo}, // SOYOMBO MARK PLUTA - {0x11A9E, 0x11AA0, prBB, gcPo}, // [3] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO HEAD MARK WITH MOON AND SUN - {0x11AA1, 0x11AA2, prBA, gcPo}, // [2] SOYOMBO TERMINAL MARK-1..SOYOMBO TERMINAL MARK-2 - {0x11AB0, 0x11ABF, prAL, gcLo}, // [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA - {0x11AC0, 0x11AF8, prAL, gcLo}, // [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL - {0x11B00, 0x11B09, prBB, gcPo}, // [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU - {0x11C00, 0x11C08, prAL, gcLo}, // [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L - {0x11C0A, 0x11C2E, prAL, gcLo}, // [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA - {0x11C2F, 0x11C2F, prCM, gcMc}, // BHAIKSUKI VOWEL SIGN AA - {0x11C30, 0x11C36, prCM, gcMn}, // [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L - {0x11C38, 0x11C3D, prCM, gcMn}, // [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA - {0x11C3E, 0x11C3E, prCM, gcMc}, // BHAIKSUKI SIGN VISARGA - {0x11C3F, 0x11C3F, prCM, gcMn}, // BHAIKSUKI SIGN VIRAMA - {0x11C40, 0x11C40, prAL, gcLo}, // BHAIKSUKI SIGN AVAGRAHA - {0x11C41, 0x11C45, prBA, gcPo}, // [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2 - {0x11C50, 0x11C59, prNU, gcNd}, // [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE - {0x11C5A, 0x11C6C, prAL, gcNo}, // [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK - {0x11C70, 0x11C70, prBB, gcPo}, // MARCHEN HEAD MARK - {0x11C71, 0x11C71, prEX, gcPo}, // MARCHEN MARK SHAD - {0x11C72, 0x11C8F, prAL, gcLo}, // [30] MARCHEN LETTER KA..MARCHEN LETTER A - {0x11C92, 0x11CA7, prCM, gcMn}, // [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA - {0x11CA9, 0x11CA9, prCM, gcMc}, // MARCHEN SUBJOINED LETTER YA - {0x11CAA, 0x11CB0, prCM, gcMn}, // [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA - {0x11CB1, 0x11CB1, prCM, gcMc}, // MARCHEN VOWEL SIGN I - {0x11CB2, 0x11CB3, prCM, gcMn}, // [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E - {0x11CB4, 0x11CB4, prCM, gcMc}, // MARCHEN VOWEL SIGN O - {0x11CB5, 0x11CB6, prCM, gcMn}, // [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU - {0x11D00, 0x11D06, prAL, gcLo}, // [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E - {0x11D08, 0x11D09, prAL, gcLo}, // [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O - {0x11D0B, 0x11D30, prAL, gcLo}, // [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA - {0x11D31, 0x11D36, prCM, gcMn}, // [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R - {0x11D3A, 0x11D3A, prCM, gcMn}, // MASARAM GONDI VOWEL SIGN E - {0x11D3C, 0x11D3D, prCM, gcMn}, // [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O - {0x11D3F, 0x11D45, prCM, gcMn}, // [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA - {0x11D46, 0x11D46, prAL, gcLo}, // MASARAM GONDI REPHA - {0x11D47, 0x11D47, prCM, gcMn}, // MASARAM GONDI RA-KARA - {0x11D50, 0x11D59, prNU, gcNd}, // [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE - {0x11D60, 0x11D65, prAL, gcLo}, // [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU - {0x11D67, 0x11D68, prAL, gcLo}, // [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI - {0x11D6A, 0x11D89, prAL, gcLo}, // [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA - {0x11D8A, 0x11D8E, prCM, gcMc}, // [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU - {0x11D90, 0x11D91, prCM, gcMn}, // [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI - {0x11D93, 0x11D94, prCM, gcMc}, // [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU - {0x11D95, 0x11D95, prCM, gcMn}, // GUNJALA GONDI SIGN ANUSVARA - {0x11D96, 0x11D96, prCM, gcMc}, // GUNJALA GONDI SIGN VISARGA - {0x11D97, 0x11D97, prCM, gcMn}, // GUNJALA GONDI VIRAMA - {0x11D98, 0x11D98, prAL, gcLo}, // GUNJALA GONDI OM - {0x11DA0, 0x11DA9, prNU, gcNd}, // [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE - {0x11EE0, 0x11EF2, prAL, gcLo}, // [19] MAKASAR LETTER KA..MAKASAR ANGKA - {0x11EF3, 0x11EF4, prCM, gcMn}, // [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U - {0x11EF5, 0x11EF6, prCM, gcMc}, // [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O - {0x11EF7, 0x11EF8, prAL, gcPo}, // [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION - {0x11F00, 0x11F01, prCM, gcMn}, // [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA - {0x11F02, 0x11F02, prAL, gcLo}, // KAWI SIGN REPHA - {0x11F03, 0x11F03, prCM, gcMc}, // KAWI SIGN VISARGA - {0x11F04, 0x11F10, prAL, gcLo}, // [13] KAWI LETTER A..KAWI LETTER O - {0x11F12, 0x11F33, prAL, gcLo}, // [34] KAWI LETTER KA..KAWI LETTER JNYA - {0x11F34, 0x11F35, prCM, gcMc}, // [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA - {0x11F36, 0x11F3A, prCM, gcMn}, // [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R - {0x11F3E, 0x11F3F, prCM, gcMc}, // [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI - {0x11F40, 0x11F40, prCM, gcMn}, // KAWI VOWEL SIGN EU - {0x11F41, 0x11F41, prCM, gcMc}, // KAWI SIGN KILLER - {0x11F42, 0x11F42, prCM, gcMn}, // KAWI CONJOINER - {0x11F43, 0x11F44, prBA, gcPo}, // [2] KAWI DANDA..KAWI DOUBLE DANDA - {0x11F45, 0x11F4F, prID, gcPo}, // [11] KAWI PUNCTUATION SECTION MARKER..KAWI PUNCTUATION CLOSING SPIRAL - {0x11F50, 0x11F59, prNU, gcNd}, // [10] KAWI DIGIT ZERO..KAWI DIGIT NINE - {0x11FB0, 0x11FB0, prAL, gcLo}, // LISU LETTER YHA - {0x11FC0, 0x11FD4, prAL, gcNo}, // [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH - {0x11FD5, 0x11FDC, prAL, gcSo}, // [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI - {0x11FDD, 0x11FE0, prPO, gcSc}, // [4] TAMIL SIGN KAACU..TAMIL SIGN VARAAKAN - {0x11FE1, 0x11FF1, prAL, gcSo}, // [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA - {0x11FFF, 0x11FFF, prBA, gcPo}, // TAMIL PUNCTUATION END OF TEXT - {0x12000, 0x12399, prAL, gcLo}, // [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U - {0x12400, 0x1246E, prAL, gcNl}, // [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM - {0x12470, 0x12474, prBA, gcPo}, // [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON - {0x12480, 0x12543, prAL, gcLo}, // [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU - {0x12F90, 0x12FF0, prAL, gcLo}, // [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 - {0x12FF1, 0x12FF2, prAL, gcPo}, // [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302 - {0x13000, 0x13257, prAL, gcLo}, // [600] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH O006 - {0x13258, 0x1325A, prOP, gcLo}, // [3] EGYPTIAN HIEROGLYPH O006A..EGYPTIAN HIEROGLYPH O006C - {0x1325B, 0x1325D, prCL, gcLo}, // [3] EGYPTIAN HIEROGLYPH O006D..EGYPTIAN HIEROGLYPH O006F - {0x1325E, 0x13281, prAL, gcLo}, // [36] EGYPTIAN HIEROGLYPH O007..EGYPTIAN HIEROGLYPH O033 - {0x13282, 0x13282, prCL, gcLo}, // EGYPTIAN HIEROGLYPH O033A - {0x13283, 0x13285, prAL, gcLo}, // [3] EGYPTIAN HIEROGLYPH O034..EGYPTIAN HIEROGLYPH O036 - {0x13286, 0x13286, prOP, gcLo}, // EGYPTIAN HIEROGLYPH O036A - {0x13287, 0x13287, prCL, gcLo}, // EGYPTIAN HIEROGLYPH O036B - {0x13288, 0x13288, prOP, gcLo}, // EGYPTIAN HIEROGLYPH O036C - {0x13289, 0x13289, prCL, gcLo}, // EGYPTIAN HIEROGLYPH O036D - {0x1328A, 0x13378, prAL, gcLo}, // [239] EGYPTIAN HIEROGLYPH O037..EGYPTIAN HIEROGLYPH V011 - {0x13379, 0x13379, prOP, gcLo}, // EGYPTIAN HIEROGLYPH V011A - {0x1337A, 0x1337B, prCL, gcLo}, // [2] EGYPTIAN HIEROGLYPH V011B..EGYPTIAN HIEROGLYPH V011C - {0x1337C, 0x1342F, prAL, gcLo}, // [180] EGYPTIAN HIEROGLYPH V012..EGYPTIAN HIEROGLYPH V011D - {0x13430, 0x13436, prGL, gcCf}, // [7] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH OVERLAY MIDDLE - {0x13437, 0x13437, prOP, gcCf}, // EGYPTIAN HIEROGLYPH BEGIN SEGMENT - {0x13438, 0x13438, prCL, gcCf}, // EGYPTIAN HIEROGLYPH END SEGMENT - {0x13439, 0x1343B, prGL, gcCf}, // [3] EGYPTIAN HIEROGLYPH INSERT AT MIDDLE..EGYPTIAN HIEROGLYPH INSERT AT BOTTOM - {0x1343C, 0x1343C, prOP, gcCf}, // EGYPTIAN HIEROGLYPH BEGIN ENCLOSURE - {0x1343D, 0x1343D, prCL, gcCf}, // EGYPTIAN HIEROGLYPH END ENCLOSURE - {0x1343E, 0x1343E, prOP, gcCf}, // EGYPTIAN HIEROGLYPH BEGIN WALLED ENCLOSURE - {0x1343F, 0x1343F, prCL, gcCf}, // EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE - {0x13440, 0x13440, prCM, gcMn}, // EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY - {0x13441, 0x13446, prAL, gcLo}, // [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN - {0x13447, 0x13455, prCM, gcMn}, // [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED - {0x14400, 0x145CD, prAL, gcLo}, // [462] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A409 - {0x145CE, 0x145CE, prOP, gcLo}, // ANATOLIAN HIEROGLYPH A410 BEGIN LOGOGRAM MARK - {0x145CF, 0x145CF, prCL, gcLo}, // ANATOLIAN HIEROGLYPH A410A END LOGOGRAM MARK - {0x145D0, 0x14646, prAL, gcLo}, // [119] ANATOLIAN HIEROGLYPH A411..ANATOLIAN HIEROGLYPH A530 - {0x16800, 0x16A38, prAL, gcLo}, // [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ - {0x16A40, 0x16A5E, prAL, gcLo}, // [31] MRO LETTER TA..MRO LETTER TEK - {0x16A60, 0x16A69, prNU, gcNd}, // [10] MRO DIGIT ZERO..MRO DIGIT NINE - {0x16A6E, 0x16A6F, prBA, gcPo}, // [2] MRO DANDA..MRO DOUBLE DANDA - {0x16A70, 0x16ABE, prAL, gcLo}, // [79] TANGSA LETTER OZ..TANGSA LETTER ZA - {0x16AC0, 0x16AC9, prNU, gcNd}, // [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE - {0x16AD0, 0x16AED, prAL, gcLo}, // [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I - {0x16AF0, 0x16AF4, prCM, gcMn}, // [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE - {0x16AF5, 0x16AF5, prBA, gcPo}, // BASSA VAH FULL STOP - {0x16B00, 0x16B2F, prAL, gcLo}, // [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU - {0x16B30, 0x16B36, prCM, gcMn}, // [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM - {0x16B37, 0x16B39, prBA, gcPo}, // [3] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN CIM CHEEM - {0x16B3A, 0x16B3B, prAL, gcPo}, // [2] PAHAWH HMONG SIGN VOS THIAB..PAHAWH HMONG SIGN VOS FEEM - {0x16B3C, 0x16B3F, prAL, gcSo}, // [4] PAHAWH HMONG SIGN XYEEM NTXIV..PAHAWH HMONG SIGN XYEEM FAIB - {0x16B40, 0x16B43, prAL, gcLm}, // [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM - {0x16B44, 0x16B44, prBA, gcPo}, // PAHAWH HMONG SIGN XAUS - {0x16B45, 0x16B45, prAL, gcSo}, // PAHAWH HMONG SIGN CIM TSOV ROG - {0x16B50, 0x16B59, prNU, gcNd}, // [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE - {0x16B5B, 0x16B61, prAL, gcNo}, // [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS - {0x16B63, 0x16B77, prAL, gcLo}, // [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS - {0x16B7D, 0x16B8F, prAL, gcLo}, // [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ - {0x16E40, 0x16E7F, prAL, gcLC}, // [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y - {0x16E80, 0x16E96, prAL, gcNo}, // [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM - {0x16E97, 0x16E98, prBA, gcPo}, // [2] MEDEFAIDRIN COMMA..MEDEFAIDRIN FULL STOP - {0x16E99, 0x16E9A, prAL, gcPo}, // [2] MEDEFAIDRIN SYMBOL AIVA..MEDEFAIDRIN EXCLAMATION OH - {0x16F00, 0x16F4A, prAL, gcLo}, // [75] MIAO LETTER PA..MIAO LETTER RTE - {0x16F4F, 0x16F4F, prCM, gcMn}, // MIAO SIGN CONSONANT MODIFIER BAR - {0x16F50, 0x16F50, prAL, gcLo}, // MIAO LETTER NASALIZATION - {0x16F51, 0x16F87, prCM, gcMc}, // [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI - {0x16F8F, 0x16F92, prCM, gcMn}, // [4] MIAO TONE RIGHT..MIAO TONE BELOW - {0x16F93, 0x16F9F, prAL, gcLm}, // [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8 - {0x16FE0, 0x16FE1, prNS, gcLm}, // [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK - {0x16FE2, 0x16FE2, prNS, gcPo}, // OLD CHINESE HOOK MARK - {0x16FE3, 0x16FE3, prNS, gcLm}, // OLD CHINESE ITERATION MARK - {0x16FE4, 0x16FE4, prGL, gcMn}, // KHITAN SMALL SCRIPT FILLER - {0x16FF0, 0x16FF1, prCM, gcMc}, // [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY - {0x17000, 0x187F7, prID, gcLo}, // [6136] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187F7 - {0x18800, 0x18AFF, prID, gcLo}, // [768] TANGUT COMPONENT-001..TANGUT COMPONENT-768 - {0x18B00, 0x18CD5, prAL, gcLo}, // [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5 - {0x18D00, 0x18D08, prID, gcLo}, // [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08 - {0x1AFF0, 0x1AFF3, prAL, gcLm}, // [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 - {0x1AFF5, 0x1AFFB, prAL, gcLm}, // [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 - {0x1AFFD, 0x1AFFE, prAL, gcLm}, // [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 - {0x1B000, 0x1B0FF, prID, gcLo}, // [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2 - {0x1B100, 0x1B122, prID, gcLo}, // [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU - {0x1B132, 0x1B132, prCJ, gcLo}, // HIRAGANA LETTER SMALL KO - {0x1B150, 0x1B152, prCJ, gcLo}, // [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO - {0x1B155, 0x1B155, prCJ, gcLo}, // KATAKANA LETTER SMALL KO - {0x1B164, 0x1B167, prCJ, gcLo}, // [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N - {0x1B170, 0x1B2FB, prID, gcLo}, // [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB - {0x1BC00, 0x1BC6A, prAL, gcLo}, // [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M - {0x1BC70, 0x1BC7C, prAL, gcLo}, // [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK - {0x1BC80, 0x1BC88, prAL, gcLo}, // [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL - {0x1BC90, 0x1BC99, prAL, gcLo}, // [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW - {0x1BC9C, 0x1BC9C, prAL, gcSo}, // DUPLOYAN SIGN O WITH CROSS - {0x1BC9D, 0x1BC9E, prCM, gcMn}, // [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK - {0x1BC9F, 0x1BC9F, prBA, gcPo}, // DUPLOYAN PUNCTUATION CHINOOK FULL STOP - {0x1BCA0, 0x1BCA3, prCM, gcCf}, // [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP - {0x1CF00, 0x1CF2D, prCM, gcMn}, // [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT - {0x1CF30, 0x1CF46, prCM, gcMn}, // [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG - {0x1CF50, 0x1CFC3, prAL, gcSo}, // [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK - {0x1D000, 0x1D0F5, prAL, gcSo}, // [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO - {0x1D100, 0x1D126, prAL, gcSo}, // [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2 - {0x1D129, 0x1D164, prAL, gcSo}, // [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE - {0x1D165, 0x1D166, prCM, gcMc}, // [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM - {0x1D167, 0x1D169, prCM, gcMn}, // [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 - {0x1D16A, 0x1D16C, prAL, gcSo}, // [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3 - {0x1D16D, 0x1D172, prCM, gcMc}, // [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 - {0x1D173, 0x1D17A, prCM, gcCf}, // [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE - {0x1D17B, 0x1D182, prCM, gcMn}, // [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE - {0x1D183, 0x1D184, prAL, gcSo}, // [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN - {0x1D185, 0x1D18B, prCM, gcMn}, // [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE - {0x1D18C, 0x1D1A9, prAL, gcSo}, // [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH - {0x1D1AA, 0x1D1AD, prCM, gcMn}, // [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO - {0x1D1AE, 0x1D1EA, prAL, gcSo}, // [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON - {0x1D200, 0x1D241, prAL, gcSo}, // [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54 - {0x1D242, 0x1D244, prCM, gcMn}, // [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME - {0x1D245, 0x1D245, prAL, gcSo}, // GREEK MUSICAL LEIMMA - {0x1D2C0, 0x1D2D3, prAL, gcNo}, // [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN - {0x1D2E0, 0x1D2F3, prAL, gcNo}, // [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN - {0x1D300, 0x1D356, prAL, gcSo}, // [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING - {0x1D360, 0x1D378, prAL, gcNo}, // [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE - {0x1D400, 0x1D454, prAL, gcLC}, // [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G - {0x1D456, 0x1D49C, prAL, gcLC}, // [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A - {0x1D49E, 0x1D49F, prAL, gcLu}, // [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D - {0x1D4A2, 0x1D4A2, prAL, gcLu}, // MATHEMATICAL SCRIPT CAPITAL G - {0x1D4A5, 0x1D4A6, prAL, gcLu}, // [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K - {0x1D4A9, 0x1D4AC, prAL, gcLu}, // [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q - {0x1D4AE, 0x1D4B9, prAL, gcLC}, // [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D - {0x1D4BB, 0x1D4BB, prAL, gcLl}, // MATHEMATICAL SCRIPT SMALL F - {0x1D4BD, 0x1D4C3, prAL, gcLl}, // [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N - {0x1D4C5, 0x1D505, prAL, gcLC}, // [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B - {0x1D507, 0x1D50A, prAL, gcLu}, // [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G - {0x1D50D, 0x1D514, prAL, gcLu}, // [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q - {0x1D516, 0x1D51C, prAL, gcLu}, // [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y - {0x1D51E, 0x1D539, prAL, gcLC}, // [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B - {0x1D53B, 0x1D53E, prAL, gcLu}, // [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G - {0x1D540, 0x1D544, prAL, gcLu}, // [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M - {0x1D546, 0x1D546, prAL, gcLu}, // MATHEMATICAL DOUBLE-STRUCK CAPITAL O - {0x1D54A, 0x1D550, prAL, gcLu}, // [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y - {0x1D552, 0x1D6A5, prAL, gcLC}, // [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J - {0x1D6A8, 0x1D6C0, prAL, gcLu}, // [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA - {0x1D6C1, 0x1D6C1, prAL, gcSm}, // MATHEMATICAL BOLD NABLA - {0x1D6C2, 0x1D6DA, prAL, gcLl}, // [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA - {0x1D6DB, 0x1D6DB, prAL, gcSm}, // MATHEMATICAL BOLD PARTIAL DIFFERENTIAL - {0x1D6DC, 0x1D6FA, prAL, gcLC}, // [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA - {0x1D6FB, 0x1D6FB, prAL, gcSm}, // MATHEMATICAL ITALIC NABLA - {0x1D6FC, 0x1D714, prAL, gcLl}, // [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA - {0x1D715, 0x1D715, prAL, gcSm}, // MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL - {0x1D716, 0x1D734, prAL, gcLC}, // [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA - {0x1D735, 0x1D735, prAL, gcSm}, // MATHEMATICAL BOLD ITALIC NABLA - {0x1D736, 0x1D74E, prAL, gcLl}, // [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA - {0x1D74F, 0x1D74F, prAL, gcSm}, // MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL - {0x1D750, 0x1D76E, prAL, gcLC}, // [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA - {0x1D76F, 0x1D76F, prAL, gcSm}, // MATHEMATICAL SANS-SERIF BOLD NABLA - {0x1D770, 0x1D788, prAL, gcLl}, // [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA - {0x1D789, 0x1D789, prAL, gcSm}, // MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL - {0x1D78A, 0x1D7A8, prAL, gcLC}, // [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA - {0x1D7A9, 0x1D7A9, prAL, gcSm}, // MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA - {0x1D7AA, 0x1D7C2, prAL, gcLl}, // [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA - {0x1D7C3, 0x1D7C3, prAL, gcSm}, // MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL - {0x1D7C4, 0x1D7CB, prAL, gcLC}, // [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA - {0x1D7CE, 0x1D7FF, prNU, gcNd}, // [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE - {0x1D800, 0x1D9FF, prAL, gcSo}, // [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD - {0x1DA00, 0x1DA36, prCM, gcMn}, // [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN - {0x1DA37, 0x1DA3A, prAL, gcSo}, // [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE - {0x1DA3B, 0x1DA6C, prCM, gcMn}, // [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT - {0x1DA6D, 0x1DA74, prAL, gcSo}, // [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING - {0x1DA75, 0x1DA75, prCM, gcMn}, // SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS - {0x1DA76, 0x1DA83, prAL, gcSo}, // [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH - {0x1DA84, 0x1DA84, prCM, gcMn}, // SIGNWRITING LOCATION HEAD NECK - {0x1DA85, 0x1DA86, prAL, gcSo}, // [2] SIGNWRITING LOCATION TORSO..SIGNWRITING LOCATION LIMBS DIGITS - {0x1DA87, 0x1DA8A, prBA, gcPo}, // [4] SIGNWRITING COMMA..SIGNWRITING COLON - {0x1DA8B, 0x1DA8B, prAL, gcPo}, // SIGNWRITING PARENTHESIS - {0x1DA9B, 0x1DA9F, prCM, gcMn}, // [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 - {0x1DAA1, 0x1DAAF, prCM, gcMn}, // [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 - {0x1DF00, 0x1DF09, prAL, gcLl}, // [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK - {0x1DF0A, 0x1DF0A, prAL, gcLo}, // LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK - {0x1DF0B, 0x1DF1E, prAL, gcLl}, // [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL - {0x1DF25, 0x1DF2A, prAL, gcLl}, // [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK - {0x1E000, 0x1E006, prCM, gcMn}, // [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE - {0x1E008, 0x1E018, prCM, gcMn}, // [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU - {0x1E01B, 0x1E021, prCM, gcMn}, // [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI - {0x1E023, 0x1E024, prCM, gcMn}, // [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS - {0x1E026, 0x1E02A, prCM, gcMn}, // [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA - {0x1E030, 0x1E06D, prAL, gcLm}, // [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE - {0x1E08F, 0x1E08F, prCM, gcMn}, // COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I - {0x1E100, 0x1E12C, prAL, gcLo}, // [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W - {0x1E130, 0x1E136, prCM, gcMn}, // [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D - {0x1E137, 0x1E13D, prAL, gcLm}, // [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER - {0x1E140, 0x1E149, prNU, gcNd}, // [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE - {0x1E14E, 0x1E14E, prAL, gcLo}, // NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ - {0x1E14F, 0x1E14F, prAL, gcSo}, // NYIAKENG PUACHUE HMONG CIRCLED CA - {0x1E290, 0x1E2AD, prAL, gcLo}, // [30] TOTO LETTER PA..TOTO LETTER A - {0x1E2AE, 0x1E2AE, prCM, gcMn}, // TOTO SIGN RISING TONE - {0x1E2C0, 0x1E2EB, prAL, gcLo}, // [44] WANCHO LETTER AA..WANCHO LETTER YIH - {0x1E2EC, 0x1E2EF, prCM, gcMn}, // [4] WANCHO TONE TUP..WANCHO TONE KOINI - {0x1E2F0, 0x1E2F9, prNU, gcNd}, // [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE - {0x1E2FF, 0x1E2FF, prPR, gcSc}, // WANCHO NGUN SIGN - {0x1E4D0, 0x1E4EA, prAL, gcLo}, // [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL - {0x1E4EB, 0x1E4EB, prAL, gcLm}, // NAG MUNDARI SIGN OJOD - {0x1E4EC, 0x1E4EF, prCM, gcMn}, // [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH - {0x1E4F0, 0x1E4F9, prNU, gcNd}, // [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE - {0x1E7E0, 0x1E7E6, prAL, gcLo}, // [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO - {0x1E7E8, 0x1E7EB, prAL, gcLo}, // [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE - {0x1E7ED, 0x1E7EE, prAL, gcLo}, // [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE - {0x1E7F0, 0x1E7FE, prAL, gcLo}, // [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE - {0x1E800, 0x1E8C4, prAL, gcLo}, // [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON - {0x1E8C7, 0x1E8CF, prAL, gcNo}, // [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE - {0x1E8D0, 0x1E8D6, prCM, gcMn}, // [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS - {0x1E900, 0x1E943, prAL, gcLC}, // [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA - {0x1E944, 0x1E94A, prCM, gcMn}, // [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA - {0x1E94B, 0x1E94B, prAL, gcLm}, // ADLAM NASALIZATION MARK - {0x1E950, 0x1E959, prNU, gcNd}, // [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE - {0x1E95E, 0x1E95F, prOP, gcPo}, // [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK - {0x1EC71, 0x1ECAB, prAL, gcNo}, // [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE - {0x1ECAC, 0x1ECAC, prPO, gcSo}, // INDIC SIYAQ PLACEHOLDER - {0x1ECAD, 0x1ECAF, prAL, gcNo}, // [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS - {0x1ECB0, 0x1ECB0, prPO, gcSc}, // INDIC SIYAQ RUPEE MARK - {0x1ECB1, 0x1ECB4, prAL, gcNo}, // [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK - {0x1ED01, 0x1ED2D, prAL, gcNo}, // [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND - {0x1ED2E, 0x1ED2E, prAL, gcSo}, // OTTOMAN SIYAQ MARRATAN - {0x1ED2F, 0x1ED3D, prAL, gcNo}, // [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH - {0x1EE00, 0x1EE03, prAL, gcLo}, // [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL - {0x1EE05, 0x1EE1F, prAL, gcLo}, // [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF - {0x1EE21, 0x1EE22, prAL, gcLo}, // [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM - {0x1EE24, 0x1EE24, prAL, gcLo}, // ARABIC MATHEMATICAL INITIAL HEH - {0x1EE27, 0x1EE27, prAL, gcLo}, // ARABIC MATHEMATICAL INITIAL HAH - {0x1EE29, 0x1EE32, prAL, gcLo}, // [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF - {0x1EE34, 0x1EE37, prAL, gcLo}, // [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH - {0x1EE39, 0x1EE39, prAL, gcLo}, // ARABIC MATHEMATICAL INITIAL DAD - {0x1EE3B, 0x1EE3B, prAL, gcLo}, // ARABIC MATHEMATICAL INITIAL GHAIN - {0x1EE42, 0x1EE42, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED JEEM - {0x1EE47, 0x1EE47, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED HAH - {0x1EE49, 0x1EE49, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED YEH - {0x1EE4B, 0x1EE4B, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED LAM - {0x1EE4D, 0x1EE4F, prAL, gcLo}, // [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN - {0x1EE51, 0x1EE52, prAL, gcLo}, // [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF - {0x1EE54, 0x1EE54, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED SHEEN - {0x1EE57, 0x1EE57, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED KHAH - {0x1EE59, 0x1EE59, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED DAD - {0x1EE5B, 0x1EE5B, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED GHAIN - {0x1EE5D, 0x1EE5D, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED DOTLESS NOON - {0x1EE5F, 0x1EE5F, prAL, gcLo}, // ARABIC MATHEMATICAL TAILED DOTLESS QAF - {0x1EE61, 0x1EE62, prAL, gcLo}, // [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM - {0x1EE64, 0x1EE64, prAL, gcLo}, // ARABIC MATHEMATICAL STRETCHED HEH - {0x1EE67, 0x1EE6A, prAL, gcLo}, // [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF - {0x1EE6C, 0x1EE72, prAL, gcLo}, // [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF - {0x1EE74, 0x1EE77, prAL, gcLo}, // [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH - {0x1EE79, 0x1EE7C, prAL, gcLo}, // [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH - {0x1EE7E, 0x1EE7E, prAL, gcLo}, // ARABIC MATHEMATICAL STRETCHED DOTLESS FEH - {0x1EE80, 0x1EE89, prAL, gcLo}, // [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH - {0x1EE8B, 0x1EE9B, prAL, gcLo}, // [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN - {0x1EEA1, 0x1EEA3, prAL, gcLo}, // [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL - {0x1EEA5, 0x1EEA9, prAL, gcLo}, // [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH - {0x1EEAB, 0x1EEBB, prAL, gcLo}, // [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN - {0x1EEF0, 0x1EEF1, prAL, gcSm}, // [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL - {0x1F000, 0x1F02B, prID, gcSo}, // [44] MAHJONG TILE EAST WIND..MAHJONG TILE BACK - {0x1F02C, 0x1F02F, prID, gcCn}, // [4] .. - {0x1F030, 0x1F093, prID, gcSo}, // [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06 - {0x1F094, 0x1F09F, prID, gcCn}, // [12] .. - {0x1F0A0, 0x1F0AE, prID, gcSo}, // [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES - {0x1F0AF, 0x1F0B0, prID, gcCn}, // [2] .. - {0x1F0B1, 0x1F0BF, prID, gcSo}, // [15] PLAYING CARD ACE OF HEARTS..PLAYING CARD RED JOKER - {0x1F0C0, 0x1F0C0, prID, gcCn}, // - {0x1F0C1, 0x1F0CF, prID, gcSo}, // [15] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD BLACK JOKER - {0x1F0D0, 0x1F0D0, prID, gcCn}, // - {0x1F0D1, 0x1F0F5, prID, gcSo}, // [37] PLAYING CARD ACE OF CLUBS..PLAYING CARD TRUMP-21 - {0x1F0F6, 0x1F0FF, prID, gcCn}, // [10] .. - {0x1F100, 0x1F10C, prAI, gcNo}, // [13] DIGIT ZERO FULL STOP..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO - {0x1F10D, 0x1F10F, prID, gcSo}, // [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH - {0x1F110, 0x1F12D, prAI, gcSo}, // [30] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED CD - {0x1F12E, 0x1F12F, prAL, gcSo}, // [2] CIRCLED WZ..COPYLEFT SYMBOL - {0x1F130, 0x1F169, prAI, gcSo}, // [58] SQUARED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z - {0x1F16A, 0x1F16C, prAL, gcSo}, // [3] RAISED MC SIGN..RAISED MR SIGN - {0x1F16D, 0x1F16F, prID, gcSo}, // [3] CIRCLED CC..CIRCLED HUMAN FIGURE - {0x1F170, 0x1F1AC, prAI, gcSo}, // [61] NEGATIVE SQUARED LATIN CAPITAL LETTER A..SQUARED VOD - {0x1F1AD, 0x1F1AD, prID, gcSo}, // MASK WORK SYMBOL - {0x1F1AE, 0x1F1E5, prID, gcCn}, // [56] .. - {0x1F1E6, 0x1F1FF, prRI, gcSo}, // [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z - {0x1F200, 0x1F202, prID, gcSo}, // [3] SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA - {0x1F203, 0x1F20F, prID, gcCn}, // [13] .. - {0x1F210, 0x1F23B, prID, gcSo}, // [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D - {0x1F23C, 0x1F23F, prID, gcCn}, // [4] .. - {0x1F240, 0x1F248, prID, gcSo}, // [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557 - {0x1F249, 0x1F24F, prID, gcCn}, // [7] .. - {0x1F250, 0x1F251, prID, gcSo}, // [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT - {0x1F252, 0x1F25F, prID, gcCn}, // [14] .. - {0x1F260, 0x1F265, prID, gcSo}, // [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI - {0x1F266, 0x1F2FF, prID, gcCn}, // [154] .. - {0x1F300, 0x1F384, prID, gcSo}, // [133] CYCLONE..CHRISTMAS TREE - {0x1F385, 0x1F385, prEB, gcSo}, // FATHER CHRISTMAS - {0x1F386, 0x1F39B, prID, gcSo}, // [22] FIREWORKS..CONTROL KNOBS - {0x1F39C, 0x1F39D, prAL, gcSo}, // [2] BEAMED ASCENDING MUSICAL NOTES..BEAMED DESCENDING MUSICAL NOTES - {0x1F39E, 0x1F3B4, prID, gcSo}, // [23] FILM FRAMES..FLOWER PLAYING CARDS - {0x1F3B5, 0x1F3B6, prAL, gcSo}, // [2] MUSICAL NOTE..MULTIPLE MUSICAL NOTES - {0x1F3B7, 0x1F3BB, prID, gcSo}, // [5] SAXOPHONE..VIOLIN - {0x1F3BC, 0x1F3BC, prAL, gcSo}, // MUSICAL SCORE - {0x1F3BD, 0x1F3C1, prID, gcSo}, // [5] RUNNING SHIRT WITH SASH..CHEQUERED FLAG - {0x1F3C2, 0x1F3C4, prEB, gcSo}, // [3] SNOWBOARDER..SURFER - {0x1F3C5, 0x1F3C6, prID, gcSo}, // [2] SPORTS MEDAL..TROPHY - {0x1F3C7, 0x1F3C7, prEB, gcSo}, // HORSE RACING - {0x1F3C8, 0x1F3C9, prID, gcSo}, // [2] AMERICAN FOOTBALL..RUGBY FOOTBALL - {0x1F3CA, 0x1F3CC, prEB, gcSo}, // [3] SWIMMER..GOLFER - {0x1F3CD, 0x1F3FA, prID, gcSo}, // [46] RACING MOTORCYCLE..AMPHORA - {0x1F3FB, 0x1F3FF, prEM, gcSk}, // [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6 - {0x1F400, 0x1F441, prID, gcSo}, // [66] RAT..EYE - {0x1F442, 0x1F443, prEB, gcSo}, // [2] EAR..NOSE - {0x1F444, 0x1F445, prID, gcSo}, // [2] MOUTH..TONGUE - {0x1F446, 0x1F450, prEB, gcSo}, // [11] WHITE UP POINTING BACKHAND INDEX..OPEN HANDS SIGN - {0x1F451, 0x1F465, prID, gcSo}, // [21] CROWN..BUSTS IN SILHOUETTE - {0x1F466, 0x1F478, prEB, gcSo}, // [19] BOY..PRINCESS - {0x1F479, 0x1F47B, prID, gcSo}, // [3] JAPANESE OGRE..GHOST - {0x1F47C, 0x1F47C, prEB, gcSo}, // BABY ANGEL - {0x1F47D, 0x1F480, prID, gcSo}, // [4] EXTRATERRESTRIAL ALIEN..SKULL - {0x1F481, 0x1F483, prEB, gcSo}, // [3] INFORMATION DESK PERSON..DANCER - {0x1F484, 0x1F484, prID, gcSo}, // LIPSTICK - {0x1F485, 0x1F487, prEB, gcSo}, // [3] NAIL POLISH..HAIRCUT - {0x1F488, 0x1F48E, prID, gcSo}, // [7] BARBER POLE..GEM STONE - {0x1F48F, 0x1F48F, prEB, gcSo}, // KISS - {0x1F490, 0x1F490, prID, gcSo}, // BOUQUET - {0x1F491, 0x1F491, prEB, gcSo}, // COUPLE WITH HEART - {0x1F492, 0x1F49F, prID, gcSo}, // [14] WEDDING..HEART DECORATION - {0x1F4A0, 0x1F4A0, prAL, gcSo}, // DIAMOND SHAPE WITH A DOT INSIDE - {0x1F4A1, 0x1F4A1, prID, gcSo}, // ELECTRIC LIGHT BULB - {0x1F4A2, 0x1F4A2, prAL, gcSo}, // ANGER SYMBOL - {0x1F4A3, 0x1F4A3, prID, gcSo}, // BOMB - {0x1F4A4, 0x1F4A4, prAL, gcSo}, // SLEEPING SYMBOL - {0x1F4A5, 0x1F4A9, prID, gcSo}, // [5] COLLISION SYMBOL..PILE OF POO - {0x1F4AA, 0x1F4AA, prEB, gcSo}, // FLEXED BICEPS - {0x1F4AB, 0x1F4AE, prID, gcSo}, // [4] DIZZY SYMBOL..WHITE FLOWER - {0x1F4AF, 0x1F4AF, prAL, gcSo}, // HUNDRED POINTS SYMBOL - {0x1F4B0, 0x1F4B0, prID, gcSo}, // MONEY BAG - {0x1F4B1, 0x1F4B2, prAL, gcSo}, // [2] CURRENCY EXCHANGE..HEAVY DOLLAR SIGN - {0x1F4B3, 0x1F4FF, prID, gcSo}, // [77] CREDIT CARD..PRAYER BEADS - {0x1F500, 0x1F506, prAL, gcSo}, // [7] TWISTED RIGHTWARDS ARROWS..HIGH BRIGHTNESS SYMBOL - {0x1F507, 0x1F516, prID, gcSo}, // [16] SPEAKER WITH CANCELLATION STROKE..BOOKMARK - {0x1F517, 0x1F524, prAL, gcSo}, // [14] LINK SYMBOL..INPUT SYMBOL FOR LATIN LETTERS - {0x1F525, 0x1F531, prID, gcSo}, // [13] FIRE..TRIDENT EMBLEM - {0x1F532, 0x1F549, prAL, gcSo}, // [24] BLACK SQUARE BUTTON..OM SYMBOL - {0x1F54A, 0x1F573, prID, gcSo}, // [42] DOVE OF PEACE..HOLE - {0x1F574, 0x1F575, prEB, gcSo}, // [2] MAN IN BUSINESS SUIT LEVITATING..SLEUTH OR SPY - {0x1F576, 0x1F579, prID, gcSo}, // [4] DARK SUNGLASSES..JOYSTICK - {0x1F57A, 0x1F57A, prEB, gcSo}, // MAN DANCING - {0x1F57B, 0x1F58F, prID, gcSo}, // [21] LEFT HAND TELEPHONE RECEIVER..TURNED OK HAND SIGN - {0x1F590, 0x1F590, prEB, gcSo}, // RAISED HAND WITH FINGERS SPLAYED - {0x1F591, 0x1F594, prID, gcSo}, // [4] REVERSED RAISED HAND WITH FINGERS SPLAYED..REVERSED VICTORY HAND - {0x1F595, 0x1F596, prEB, gcSo}, // [2] REVERSED HAND WITH MIDDLE FINGER EXTENDED..RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS - {0x1F597, 0x1F5D3, prID, gcSo}, // [61] WHITE DOWN POINTING LEFT HAND INDEX..SPIRAL CALENDAR PAD - {0x1F5D4, 0x1F5DB, prAL, gcSo}, // [8] DESKTOP WINDOW..DECREASE FONT SIZE SYMBOL - {0x1F5DC, 0x1F5F3, prID, gcSo}, // [24] COMPRESSION..BALLOT BOX WITH BALLOT - {0x1F5F4, 0x1F5F9, prAL, gcSo}, // [6] BALLOT SCRIPT X..BALLOT BOX WITH BOLD CHECK - {0x1F5FA, 0x1F5FF, prID, gcSo}, // [6] WORLD MAP..MOYAI - {0x1F600, 0x1F644, prID, gcSo}, // [69] GRINNING FACE..FACE WITH ROLLING EYES - {0x1F645, 0x1F647, prEB, gcSo}, // [3] FACE WITH NO GOOD GESTURE..PERSON BOWING DEEPLY - {0x1F648, 0x1F64A, prID, gcSo}, // [3] SEE-NO-EVIL MONKEY..SPEAK-NO-EVIL MONKEY - {0x1F64B, 0x1F64F, prEB, gcSo}, // [5] HAPPY PERSON RAISING ONE HAND..PERSON WITH FOLDED HANDS - {0x1F650, 0x1F675, prAL, gcSo}, // [38] NORTH WEST POINTING LEAF..SWASH AMPERSAND ORNAMENT - {0x1F676, 0x1F678, prQU, gcSo}, // [3] SANS-SERIF HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT..SANS-SERIF HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT - {0x1F679, 0x1F67B, prNS, gcSo}, // [3] HEAVY INTERROBANG ORNAMENT..HEAVY SANS-SERIF INTERROBANG ORNAMENT - {0x1F67C, 0x1F67F, prAL, gcSo}, // [4] VERY HEAVY SOLIDUS..REVERSE CHECKER BOARD - {0x1F680, 0x1F6A2, prID, gcSo}, // [35] ROCKET..SHIP - {0x1F6A3, 0x1F6A3, prEB, gcSo}, // ROWBOAT - {0x1F6A4, 0x1F6B3, prID, gcSo}, // [16] SPEEDBOAT..NO BICYCLES - {0x1F6B4, 0x1F6B6, prEB, gcSo}, // [3] BICYCLIST..PEDESTRIAN - {0x1F6B7, 0x1F6BF, prID, gcSo}, // [9] NO PEDESTRIANS..SHOWER - {0x1F6C0, 0x1F6C0, prEB, gcSo}, // BATH - {0x1F6C1, 0x1F6CB, prID, gcSo}, // [11] BATHTUB..COUCH AND LAMP - {0x1F6CC, 0x1F6CC, prEB, gcSo}, // SLEEPING ACCOMMODATION - {0x1F6CD, 0x1F6D7, prID, gcSo}, // [11] SHOPPING BAGS..ELEVATOR - {0x1F6D8, 0x1F6DB, prID, gcCn}, // [4] .. - {0x1F6DC, 0x1F6EC, prID, gcSo}, // [17] WIRELESS..AIRPLANE ARRIVING - {0x1F6ED, 0x1F6EF, prID, gcCn}, // [3] .. - {0x1F6F0, 0x1F6FC, prID, gcSo}, // [13] SATELLITE..ROLLER SKATE - {0x1F6FD, 0x1F6FF, prID, gcCn}, // [3] .. - {0x1F700, 0x1F773, prAL, gcSo}, // [116] ALCHEMICAL SYMBOL FOR QUINTESSENCE..ALCHEMICAL SYMBOL FOR HALF OUNCE - {0x1F774, 0x1F776, prID, gcSo}, // [3] LOT OF FORTUNE..LUNAR ECLIPSE - {0x1F777, 0x1F77A, prID, gcCn}, // [4] .. - {0x1F77B, 0x1F77F, prID, gcSo}, // [5] HAUMEA..ORCUS - {0x1F780, 0x1F7D4, prAL, gcSo}, // [85] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..HEAVY TWELVE POINTED PINWHEEL STAR - {0x1F7D5, 0x1F7D9, prID, gcSo}, // [5] CIRCLED TRIANGLE..NINE POINTED WHITE STAR - {0x1F7DA, 0x1F7DF, prID, gcCn}, // [6] .. - {0x1F7E0, 0x1F7EB, prID, gcSo}, // [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE - {0x1F7EC, 0x1F7EF, prID, gcCn}, // [4] .. - {0x1F7F0, 0x1F7F0, prID, gcSo}, // HEAVY EQUALS SIGN - {0x1F7F1, 0x1F7FF, prID, gcCn}, // [15] .. - {0x1F800, 0x1F80B, prAL, gcSo}, // [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD - {0x1F80C, 0x1F80F, prID, gcCn}, // [4] .. - {0x1F810, 0x1F847, prAL, gcSo}, // [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW - {0x1F848, 0x1F84F, prID, gcCn}, // [8] .. - {0x1F850, 0x1F859, prAL, gcSo}, // [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW - {0x1F85A, 0x1F85F, prID, gcCn}, // [6] .. - {0x1F860, 0x1F887, prAL, gcSo}, // [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW - {0x1F888, 0x1F88F, prID, gcCn}, // [8] .. - {0x1F890, 0x1F8AD, prAL, gcSo}, // [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS - {0x1F8AE, 0x1F8AF, prID, gcCn}, // [2] .. - {0x1F8B0, 0x1F8B1, prID, gcSo}, // [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST - {0x1F8B2, 0x1F8FF, prID, gcCn}, // [78] .. - {0x1F900, 0x1F90B, prAL, gcSo}, // [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT - {0x1F90C, 0x1F90C, prEB, gcSo}, // PINCHED FINGERS - {0x1F90D, 0x1F90E, prID, gcSo}, // [2] WHITE HEART..BROWN HEART - {0x1F90F, 0x1F90F, prEB, gcSo}, // PINCHING HAND - {0x1F910, 0x1F917, prID, gcSo}, // [8] ZIPPER-MOUTH FACE..HUGGING FACE - {0x1F918, 0x1F91F, prEB, gcSo}, // [8] SIGN OF THE HORNS..I LOVE YOU HAND SIGN - {0x1F920, 0x1F925, prID, gcSo}, // [6] FACE WITH COWBOY HAT..LYING FACE - {0x1F926, 0x1F926, prEB, gcSo}, // FACE PALM - {0x1F927, 0x1F92F, prID, gcSo}, // [9] SNEEZING FACE..SHOCKED FACE WITH EXPLODING HEAD - {0x1F930, 0x1F939, prEB, gcSo}, // [10] PREGNANT WOMAN..JUGGLING - {0x1F93A, 0x1F93B, prID, gcSo}, // [2] FENCER..MODERN PENTATHLON - {0x1F93C, 0x1F93E, prEB, gcSo}, // [3] WRESTLERS..HANDBALL - {0x1F93F, 0x1F976, prID, gcSo}, // [56] DIVING MASK..FREEZING FACE - {0x1F977, 0x1F977, prEB, gcSo}, // NINJA - {0x1F978, 0x1F9B4, prID, gcSo}, // [61] DISGUISED FACE..BONE - {0x1F9B5, 0x1F9B6, prEB, gcSo}, // [2] LEG..FOOT - {0x1F9B7, 0x1F9B7, prID, gcSo}, // TOOTH - {0x1F9B8, 0x1F9B9, prEB, gcSo}, // [2] SUPERHERO..SUPERVILLAIN - {0x1F9BA, 0x1F9BA, prID, gcSo}, // SAFETY VEST - {0x1F9BB, 0x1F9BB, prEB, gcSo}, // EAR WITH HEARING AID - {0x1F9BC, 0x1F9CC, prID, gcSo}, // [17] MOTORIZED WHEELCHAIR..TROLL - {0x1F9CD, 0x1F9CF, prEB, gcSo}, // [3] STANDING PERSON..DEAF PERSON - {0x1F9D0, 0x1F9D0, prID, gcSo}, // FACE WITH MONOCLE - {0x1F9D1, 0x1F9DD, prEB, gcSo}, // [13] ADULT..ELF - {0x1F9DE, 0x1F9FF, prID, gcSo}, // [34] GENIE..NAZAR AMULET - {0x1FA00, 0x1FA53, prAL, gcSo}, // [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP - {0x1FA54, 0x1FA5F, prID, gcCn}, // [12] .. - {0x1FA60, 0x1FA6D, prID, gcSo}, // [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER - {0x1FA6E, 0x1FA6F, prID, gcCn}, // [2] .. - {0x1FA70, 0x1FA7C, prID, gcSo}, // [13] BALLET SHOES..CRUTCH - {0x1FA7D, 0x1FA7F, prID, gcCn}, // [3] .. - {0x1FA80, 0x1FA88, prID, gcSo}, // [9] YO-YO..FLUTE - {0x1FA89, 0x1FA8F, prID, gcCn}, // [7] .. - {0x1FA90, 0x1FABD, prID, gcSo}, // [46] RINGED PLANET..WING - {0x1FABE, 0x1FABE, prID, gcCn}, // - {0x1FABF, 0x1FAC2, prID, gcSo}, // [4] GOOSE..PEOPLE HUGGING - {0x1FAC3, 0x1FAC5, prEB, gcSo}, // [3] PREGNANT MAN..PERSON WITH CROWN - {0x1FAC6, 0x1FACD, prID, gcCn}, // [8] .. - {0x1FACE, 0x1FADB, prID, gcSo}, // [14] MOOSE..PEA POD - {0x1FADC, 0x1FADF, prID, gcCn}, // [4] .. - {0x1FAE0, 0x1FAE8, prID, gcSo}, // [9] MELTING FACE..SHAKING FACE - {0x1FAE9, 0x1FAEF, prID, gcCn}, // [7] .. - {0x1FAF0, 0x1FAF8, prEB, gcSo}, // [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND - {0x1FAF9, 0x1FAFF, prID, gcCn}, // [7] .. - {0x1FB00, 0x1FB92, prAL, gcSo}, // [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK - {0x1FB94, 0x1FBCA, prAL, gcSo}, // [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON - {0x1FBF0, 0x1FBF9, prNU, gcNd}, // [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE - {0x1FC00, 0x1FFFD, prID, gcCn}, // [1022] .. - {0x20000, 0x2A6DF, prID, gcLo}, // [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF - {0x2A6E0, 0x2A6FF, prID, gcCn}, // [32] .. - {0x2A700, 0x2B739, prID, gcLo}, // [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739 - {0x2B73A, 0x2B73F, prID, gcCn}, // [6] .. - {0x2B740, 0x2B81D, prID, gcLo}, // [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D - {0x2B81E, 0x2B81F, prID, gcCn}, // [2] .. - {0x2B820, 0x2CEA1, prID, gcLo}, // [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1 - {0x2CEA2, 0x2CEAF, prID, gcCn}, // [14] .. - {0x2CEB0, 0x2EBE0, prID, gcLo}, // [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 - {0x2EBE1, 0x2F7FF, prID, gcCn}, // [3103] .. - {0x2F800, 0x2FA1D, prID, gcLo}, // [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D - {0x2FA1E, 0x2FA1F, prID, gcCn}, // [2] .. - {0x2FA20, 0x2FFFD, prID, gcCn}, // [1502] .. - {0x30000, 0x3134A, prID, gcLo}, // [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A - {0x3134B, 0x3134F, prID, gcCn}, // [5] .. - {0x31350, 0x323AF, prID, gcLo}, // [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF - {0x323B0, 0x3FFFD, prID, gcCn}, // [56398] .. - {0xE0001, 0xE0001, prCM, gcCf}, // LANGUAGE TAG - {0xE0020, 0xE007F, prCM, gcCf}, // [96] TAG SPACE..CANCEL TAG - {0xE0100, 0xE01EF, prCM, gcMn}, // [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 - {0xF0000, 0xFFFFD, prXX, gcCo}, // [65534] .. - {0x100000, 0x10FFFD, prXX, gcCo}, // [65534] .. -} diff --git a/vendor/github.com/rivo/uniseg/linerules.go b/vendor/github.com/rivo/uniseg/linerules.go deleted file mode 100644 index 7708ae0..0000000 --- a/vendor/github.com/rivo/uniseg/linerules.go +++ /dev/null @@ -1,626 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// The states of the line break parser. -const ( - lbAny = iota - lbBK - lbCR - lbLF - lbNL - lbSP - lbZW - lbWJ - lbGL - lbBA - lbHY - lbCL - lbCP - lbEX - lbIS - lbSY - lbOP - lbQU - lbQUSP - lbNS - lbCLCPSP - lbB2 - lbB2SP - lbCB - lbBB - lbLB21a - lbHL - lbAL - lbNU - lbPR - lbEB - lbIDEM - lbNUNU - lbNUSY - lbNUIS - lbNUCL - lbNUCP - lbPO - lbJL - lbJV - lbJT - lbH2 - lbH3 - lbOddRI - lbEvenRI - lbExtPicCn - lbZWJBit = 64 - lbCPeaFWHBit = 128 -) - -// These constants define whether a given text may be broken into the next line. -// If the break is optional (LineCanBreak), you may choose to break or not based -// on your own criteria, for example, if the text has reached the available -// width. -const ( - LineDontBreak = iota // You may not break the line here. - LineCanBreak // You may or may not break the line here. - LineMustBreak // You must break the line here. -) - -// lbTransitions implements the line break parser's state transitions. It's -// anologous to [grTransitions], see comments there for details. -// -// Unicode version 15.0.0. -func lbTransitions(state, prop int) (newState, lineBreak, rule int) { - switch uint64(state) | uint64(prop)<<32 { - // LB4. - case lbBK | prAny<<32: - return lbAny, LineMustBreak, 40 - - // LB5. - case lbCR | prLF<<32: - return lbLF, LineDontBreak, 50 - case lbCR | prAny<<32: - return lbAny, LineMustBreak, 50 - case lbLF | prAny<<32: - return lbAny, LineMustBreak, 50 - case lbNL | prAny<<32: - return lbAny, LineMustBreak, 50 - - // LB6. - case lbAny | prBK<<32: - return lbBK, LineDontBreak, 60 - case lbAny | prCR<<32: - return lbCR, LineDontBreak, 60 - case lbAny | prLF<<32: - return lbLF, LineDontBreak, 60 - case lbAny | prNL<<32: - return lbNL, LineDontBreak, 60 - - // LB7. - case lbAny | prSP<<32: - return lbSP, LineDontBreak, 70 - case lbAny | prZW<<32: - return lbZW, LineDontBreak, 70 - - // LB8. - case lbZW | prSP<<32: - return lbZW, LineDontBreak, 70 - case lbZW | prAny<<32: - return lbAny, LineCanBreak, 80 - - // LB11. - case lbAny | prWJ<<32: - return lbWJ, LineDontBreak, 110 - case lbWJ | prAny<<32: - return lbAny, LineDontBreak, 110 - - // LB12. - case lbAny | prGL<<32: - return lbGL, LineCanBreak, 310 - case lbGL | prAny<<32: - return lbAny, LineDontBreak, 120 - - // LB13 (simple transitions). - case lbAny | prCL<<32: - return lbCL, LineCanBreak, 310 - case lbAny | prCP<<32: - return lbCP, LineCanBreak, 310 - case lbAny | prEX<<32: - return lbEX, LineDontBreak, 130 - case lbAny | prIS<<32: - return lbIS, LineCanBreak, 310 - case lbAny | prSY<<32: - return lbSY, LineCanBreak, 310 - - // LB14. - case lbAny | prOP<<32: - return lbOP, LineCanBreak, 310 - case lbOP | prSP<<32: - return lbOP, LineDontBreak, 70 - case lbOP | prAny<<32: - return lbAny, LineDontBreak, 140 - - // LB15. - case lbQU | prSP<<32: - return lbQUSP, LineDontBreak, 70 - case lbQU | prOP<<32: - return lbOP, LineDontBreak, 150 - case lbQUSP | prOP<<32: - return lbOP, LineDontBreak, 150 - - // LB16. - case lbCL | prSP<<32: - return lbCLCPSP, LineDontBreak, 70 - case lbNUCL | prSP<<32: - return lbCLCPSP, LineDontBreak, 70 - case lbCP | prSP<<32: - return lbCLCPSP, LineDontBreak, 70 - case lbNUCP | prSP<<32: - return lbCLCPSP, LineDontBreak, 70 - case lbCL | prNS<<32: - return lbNS, LineDontBreak, 160 - case lbNUCL | prNS<<32: - return lbNS, LineDontBreak, 160 - case lbCP | prNS<<32: - return lbNS, LineDontBreak, 160 - case lbNUCP | prNS<<32: - return lbNS, LineDontBreak, 160 - case lbCLCPSP | prNS<<32: - return lbNS, LineDontBreak, 160 - - // LB17. - case lbAny | prB2<<32: - return lbB2, LineCanBreak, 310 - case lbB2 | prSP<<32: - return lbB2SP, LineDontBreak, 70 - case lbB2 | prB2<<32: - return lbB2, LineDontBreak, 170 - case lbB2SP | prB2<<32: - return lbB2, LineDontBreak, 170 - - // LB18. - case lbSP | prAny<<32: - return lbAny, LineCanBreak, 180 - case lbQUSP | prAny<<32: - return lbAny, LineCanBreak, 180 - case lbCLCPSP | prAny<<32: - return lbAny, LineCanBreak, 180 - case lbB2SP | prAny<<32: - return lbAny, LineCanBreak, 180 - - // LB19. - case lbAny | prQU<<32: - return lbQU, LineDontBreak, 190 - case lbQU | prAny<<32: - return lbAny, LineDontBreak, 190 - - // LB20. - case lbAny | prCB<<32: - return lbCB, LineCanBreak, 200 - case lbCB | prAny<<32: - return lbAny, LineCanBreak, 200 - - // LB21. - case lbAny | prBA<<32: - return lbBA, LineDontBreak, 210 - case lbAny | prHY<<32: - return lbHY, LineDontBreak, 210 - case lbAny | prNS<<32: - return lbNS, LineDontBreak, 210 - case lbAny | prBB<<32: - return lbBB, LineCanBreak, 310 - case lbBB | prAny<<32: - return lbAny, LineDontBreak, 210 - - // LB21a. - case lbAny | prHL<<32: - return lbHL, LineCanBreak, 310 - case lbHL | prHY<<32: - return lbLB21a, LineDontBreak, 210 - case lbHL | prBA<<32: - return lbLB21a, LineDontBreak, 210 - case lbLB21a | prAny<<32: - return lbAny, LineDontBreak, 211 - - // LB21b. - case lbSY | prHL<<32: - return lbHL, LineDontBreak, 212 - case lbNUSY | prHL<<32: - return lbHL, LineDontBreak, 212 - - // LB22. - case lbAny | prIN<<32: - return lbAny, LineDontBreak, 220 - - // LB23. - case lbAny | prAL<<32: - return lbAL, LineCanBreak, 310 - case lbAny | prNU<<32: - return lbNU, LineCanBreak, 310 - case lbAL | prNU<<32: - return lbNU, LineDontBreak, 230 - case lbHL | prNU<<32: - return lbNU, LineDontBreak, 230 - case lbNU | prAL<<32: - return lbAL, LineDontBreak, 230 - case lbNU | prHL<<32: - return lbHL, LineDontBreak, 230 - case lbNUNU | prAL<<32: - return lbAL, LineDontBreak, 230 - case lbNUNU | prHL<<32: - return lbHL, LineDontBreak, 230 - - // LB23a. - case lbAny | prPR<<32: - return lbPR, LineCanBreak, 310 - case lbAny | prID<<32: - return lbIDEM, LineCanBreak, 310 - case lbAny | prEB<<32: - return lbEB, LineCanBreak, 310 - case lbAny | prEM<<32: - return lbIDEM, LineCanBreak, 310 - case lbPR | prID<<32: - return lbIDEM, LineDontBreak, 231 - case lbPR | prEB<<32: - return lbEB, LineDontBreak, 231 - case lbPR | prEM<<32: - return lbIDEM, LineDontBreak, 231 - case lbIDEM | prPO<<32: - return lbPO, LineDontBreak, 231 - case lbEB | prPO<<32: - return lbPO, LineDontBreak, 231 - - // LB24. - case lbAny | prPO<<32: - return lbPO, LineCanBreak, 310 - case lbPR | prAL<<32: - return lbAL, LineDontBreak, 240 - case lbPR | prHL<<32: - return lbHL, LineDontBreak, 240 - case lbPO | prAL<<32: - return lbAL, LineDontBreak, 240 - case lbPO | prHL<<32: - return lbHL, LineDontBreak, 240 - case lbAL | prPR<<32: - return lbPR, LineDontBreak, 240 - case lbAL | prPO<<32: - return lbPO, LineDontBreak, 240 - case lbHL | prPR<<32: - return lbPR, LineDontBreak, 240 - case lbHL | prPO<<32: - return lbPO, LineDontBreak, 240 - - // LB25 (simple transitions). - case lbPR | prNU<<32: - return lbNU, LineDontBreak, 250 - case lbPO | prNU<<32: - return lbNU, LineDontBreak, 250 - case lbOP | prNU<<32: - return lbNU, LineDontBreak, 250 - case lbHY | prNU<<32: - return lbNU, LineDontBreak, 250 - case lbNU | prNU<<32: - return lbNUNU, LineDontBreak, 250 - case lbNU | prSY<<32: - return lbNUSY, LineDontBreak, 250 - case lbNU | prIS<<32: - return lbNUIS, LineDontBreak, 250 - case lbNUNU | prNU<<32: - return lbNUNU, LineDontBreak, 250 - case lbNUNU | prSY<<32: - return lbNUSY, LineDontBreak, 250 - case lbNUNU | prIS<<32: - return lbNUIS, LineDontBreak, 250 - case lbNUSY | prNU<<32: - return lbNUNU, LineDontBreak, 250 - case lbNUSY | prSY<<32: - return lbNUSY, LineDontBreak, 250 - case lbNUSY | prIS<<32: - return lbNUIS, LineDontBreak, 250 - case lbNUIS | prNU<<32: - return lbNUNU, LineDontBreak, 250 - case lbNUIS | prSY<<32: - return lbNUSY, LineDontBreak, 250 - case lbNUIS | prIS<<32: - return lbNUIS, LineDontBreak, 250 - case lbNU | prCL<<32: - return lbNUCL, LineDontBreak, 250 - case lbNU | prCP<<32: - return lbNUCP, LineDontBreak, 250 - case lbNUNU | prCL<<32: - return lbNUCL, LineDontBreak, 250 - case lbNUNU | prCP<<32: - return lbNUCP, LineDontBreak, 250 - case lbNUSY | prCL<<32: - return lbNUCL, LineDontBreak, 250 - case lbNUSY | prCP<<32: - return lbNUCP, LineDontBreak, 250 - case lbNUIS | prCL<<32: - return lbNUCL, LineDontBreak, 250 - case lbNUIS | prCP<<32: - return lbNUCP, LineDontBreak, 250 - case lbNU | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNUNU | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNUSY | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNUIS | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNUCL | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNUCP | prPO<<32: - return lbPO, LineDontBreak, 250 - case lbNU | prPR<<32: - return lbPR, LineDontBreak, 250 - case lbNUNU | prPR<<32: - return lbPR, LineDontBreak, 250 - case lbNUSY | prPR<<32: - return lbPR, LineDontBreak, 250 - case lbNUIS | prPR<<32: - return lbPR, LineDontBreak, 250 - case lbNUCL | prPR<<32: - return lbPR, LineDontBreak, 250 - case lbNUCP | prPR<<32: - return lbPR, LineDontBreak, 250 - - // LB26. - case lbAny | prJL<<32: - return lbJL, LineCanBreak, 310 - case lbAny | prJV<<32: - return lbJV, LineCanBreak, 310 - case lbAny | prJT<<32: - return lbJT, LineCanBreak, 310 - case lbAny | prH2<<32: - return lbH2, LineCanBreak, 310 - case lbAny | prH3<<32: - return lbH3, LineCanBreak, 310 - case lbJL | prJL<<32: - return lbJL, LineDontBreak, 260 - case lbJL | prJV<<32: - return lbJV, LineDontBreak, 260 - case lbJL | prH2<<32: - return lbH2, LineDontBreak, 260 - case lbJL | prH3<<32: - return lbH3, LineDontBreak, 260 - case lbJV | prJV<<32: - return lbJV, LineDontBreak, 260 - case lbJV | prJT<<32: - return lbJT, LineDontBreak, 260 - case lbH2 | prJV<<32: - return lbJV, LineDontBreak, 260 - case lbH2 | prJT<<32: - return lbJT, LineDontBreak, 260 - case lbJT | prJT<<32: - return lbJT, LineDontBreak, 260 - case lbH3 | prJT<<32: - return lbJT, LineDontBreak, 260 - - // LB27. - case lbJL | prPO<<32: - return lbPO, LineDontBreak, 270 - case lbJV | prPO<<32: - return lbPO, LineDontBreak, 270 - case lbJT | prPO<<32: - return lbPO, LineDontBreak, 270 - case lbH2 | prPO<<32: - return lbPO, LineDontBreak, 270 - case lbH3 | prPO<<32: - return lbPO, LineDontBreak, 270 - case lbPR | prJL<<32: - return lbJL, LineDontBreak, 270 - case lbPR | prJV<<32: - return lbJV, LineDontBreak, 270 - case lbPR | prJT<<32: - return lbJT, LineDontBreak, 270 - case lbPR | prH2<<32: - return lbH2, LineDontBreak, 270 - case lbPR | prH3<<32: - return lbH3, LineDontBreak, 270 - - // LB28. - case lbAL | prAL<<32: - return lbAL, LineDontBreak, 280 - case lbAL | prHL<<32: - return lbHL, LineDontBreak, 280 - case lbHL | prAL<<32: - return lbAL, LineDontBreak, 280 - case lbHL | prHL<<32: - return lbHL, LineDontBreak, 280 - - // LB29. - case lbIS | prAL<<32: - return lbAL, LineDontBreak, 290 - case lbIS | prHL<<32: - return lbHL, LineDontBreak, 290 - case lbNUIS | prAL<<32: - return lbAL, LineDontBreak, 290 - case lbNUIS | prHL<<32: - return lbHL, LineDontBreak, 290 - - default: - return -1, -1, -1 - } -} - -// transitionLineBreakState determines the new state of the line break parser -// given the current state and the next code point. It also returns the type of -// line break: LineDontBreak, LineCanBreak, or LineMustBreak. If more than one -// code point is needed to determine the new state, the byte slice or the string -// starting after rune "r" can be used (whichever is not nil or empty) for -// further lookups. -func transitionLineBreakState(state int, r rune, b []byte, str string) (newState int, lineBreak int) { - // Determine the property of the next character. - nextProperty, generalCategory := propertyLineBreak(r) - - // Prepare. - var forceNoBreak, isCPeaFWH bool - if state >= 0 && state&lbCPeaFWHBit != 0 { - isCPeaFWH = true // LB30: CP but ea is not F, W, or H. - state = state &^ lbCPeaFWHBit - } - if state >= 0 && state&lbZWJBit != 0 { - state = state &^ lbZWJBit // Extract zero-width joiner bit. - forceNoBreak = true // LB8a. - } - - defer func() { - // Transition into LB30. - if newState == lbCP || newState == lbNUCP { - ea := propertyEastAsianWidth(r) - if ea != prF && ea != prW && ea != prH { - newState |= lbCPeaFWHBit - } - } - - // Override break. - if forceNoBreak { - lineBreak = LineDontBreak - } - }() - - // LB1. - if nextProperty == prAI || nextProperty == prSG || nextProperty == prXX { - nextProperty = prAL - } else if nextProperty == prSA { - if generalCategory == gcMn || generalCategory == gcMc { - nextProperty = prCM - } else { - nextProperty = prAL - } - } else if nextProperty == prCJ { - nextProperty = prNS - } - - // Combining marks. - if nextProperty == prZWJ || nextProperty == prCM { - var bit int - if nextProperty == prZWJ { - bit = lbZWJBit - } - mustBreakState := state < 0 || state == lbBK || state == lbCR || state == lbLF || state == lbNL - if !mustBreakState && state != lbSP && state != lbZW && state != lbQUSP && state != lbCLCPSP && state != lbB2SP { - // LB9. - return state | bit, LineDontBreak - } else { - // LB10. - if mustBreakState { - return lbAL | bit, LineMustBreak - } - return lbAL | bit, LineCanBreak - } - } - - // Find the applicable transition in the table. - var rule int - newState, lineBreak, rule = lbTransitions(state, nextProperty) - if newState < 0 { - // No specific transition found. Try the less specific ones. - anyPropProp, anyPropLineBreak, anyPropRule := lbTransitions(state, prAny) - anyStateProp, anyStateLineBreak, anyStateRule := lbTransitions(lbAny, nextProperty) - if anyPropProp >= 0 && anyStateProp >= 0 { - // Both apply. We'll use a mix (see comments for grTransitions). - newState, lineBreak, rule = anyStateProp, anyStateLineBreak, anyStateRule - if anyPropRule < anyStateRule { - lineBreak, rule = anyPropLineBreak, anyPropRule - } - } else if anyPropProp >= 0 { - // We only have a specific state. - newState, lineBreak, rule = anyPropProp, anyPropLineBreak, anyPropRule - // This branch will probably never be reached because okAnyState will - // always be true given the current transition map. But we keep it here - // for future modifications to the transition map where this may not be - // true anymore. - } else if anyStateProp >= 0 { - // We only have a specific property. - newState, lineBreak, rule = anyStateProp, anyStateLineBreak, anyStateRule - } else { - // No known transition. LB31: ALL ÷ ALL. - newState, lineBreak, rule = lbAny, LineCanBreak, 310 - } - } - - // LB12a. - if rule > 121 && - nextProperty == prGL && - (state != lbSP && state != lbBA && state != lbHY && state != lbLB21a && state != lbQUSP && state != lbCLCPSP && state != lbB2SP) { - return lbGL, LineDontBreak - } - - // LB13. - if rule > 130 && state != lbNU && state != lbNUNU { - switch nextProperty { - case prCL: - return lbCL, LineDontBreak - case prCP: - return lbCP, LineDontBreak - case prIS: - return lbIS, LineDontBreak - case prSY: - return lbSY, LineDontBreak - } - } - - // LB25 (look ahead). - if rule > 250 && - (state == lbPR || state == lbPO) && - nextProperty == prOP || nextProperty == prHY { - var r rune - if b != nil { // Byte slice version. - r, _ = utf8.DecodeRune(b) - } else { // String version. - r, _ = utf8.DecodeRuneInString(str) - } - if r != utf8.RuneError { - pr, _ := propertyLineBreak(r) - if pr == prNU { - return lbNU, LineDontBreak - } - } - } - - // LB30 (part one). - if rule > 300 { - if (state == lbAL || state == lbHL || state == lbNU || state == lbNUNU) && nextProperty == prOP { - ea := propertyEastAsianWidth(r) - if ea != prF && ea != prW && ea != prH { - return lbOP, LineDontBreak - } - } else if isCPeaFWH { - switch nextProperty { - case prAL: - return lbAL, LineDontBreak - case prHL: - return lbHL, LineDontBreak - case prNU: - return lbNU, LineDontBreak - } - } - } - - // LB30a. - if newState == lbAny && nextProperty == prRI { - if state != lbOddRI && state != lbEvenRI { // Includes state == -1. - // Transition into the first RI. - return lbOddRI, lineBreak - } - if state == lbOddRI { - // Don't break pairs of Regional Indicators. - return lbEvenRI, LineDontBreak - } - return lbOddRI, lineBreak - } - - // LB30b. - if rule > 302 { - if nextProperty == prEM { - if state == lbEB || state == lbExtPicCn { - return prAny, LineDontBreak - } - } - graphemeProperty := propertyGraphemes(r) - if graphemeProperty == prExtendedPictographic && generalCategory == gcCn { - return lbExtPicCn, LineCanBreak - } - } - - return -} diff --git a/vendor/github.com/rivo/uniseg/properties.go b/vendor/github.com/rivo/uniseg/properties.go deleted file mode 100644 index 6290e68..0000000 --- a/vendor/github.com/rivo/uniseg/properties.go +++ /dev/null @@ -1,208 +0,0 @@ -package uniseg - -// The Unicode properties as used in the various parsers. Only the ones needed -// in the context of this package are included. -const ( - prXX = 0 // Same as prAny. - prAny = iota // prAny must be 0. - prPrepend // Grapheme properties must come first, to reduce the number of bits stored in the state vector. - prCR - prLF - prControl - prExtend - prRegionalIndicator - prSpacingMark - prL - prV - prT - prLV - prLVT - prZWJ - prExtendedPictographic - prNewline - prWSegSpace - prDoubleQuote - prSingleQuote - prMidNumLet - prNumeric - prMidLetter - prMidNum - prExtendNumLet - prALetter - prFormat - prHebrewLetter - prKatakana - prSp - prSTerm - prClose - prSContinue - prATerm - prUpper - prLower - prSep - prOLetter - prCM - prBA - prBK - prSP - prEX - prQU - prAL - prPR - prPO - prOP - prCP - prIS - prHY - prSY - prNU - prCL - prNL - prGL - prAI - prBB - prHL - prSA - prJL - prJV - prJT - prNS - prZW - prB2 - prIN - prWJ - prID - prEB - prCJ - prH2 - prH3 - prSG - prCB - prRI - prEM - prN - prNa - prA - prW - prH - prF - prEmojiPresentation -) - -// Unicode General Categories. Only the ones needed in the context of this -// package are included. -const ( - gcNone = iota // gcNone must be 0. - gcCc - gcZs - gcPo - gcSc - gcPs - gcPe - gcSm - gcPd - gcNd - gcLu - gcSk - gcPc - gcLl - gcSo - gcLo - gcPi - gcCf - gcNo - gcPf - gcLC - gcLm - gcMn - gcMe - gcMc - gcNl - gcZl - gcZp - gcCn - gcCs - gcCo -) - -// Special code points. -const ( - vs15 = 0xfe0e // Variation Selector-15 (text presentation) - vs16 = 0xfe0f // Variation Selector-16 (emoji presentation) -) - -// propertySearch performs a binary search on a property slice and returns the -// entry whose range (start = first array element, end = second array element) -// includes r, or an array of 0's if no such entry was found. -func propertySearch[E interface{ [3]int | [4]int }](dictionary []E, r rune) (result E) { - // Run a binary search. - from := 0 - to := len(dictionary) - for to > from { - middle := (from + to) / 2 - cpRange := dictionary[middle] - if int(r) < cpRange[0] { - to = middle - continue - } - if int(r) > cpRange[1] { - from = middle + 1 - continue - } - return cpRange - } - return -} - -// property returns the Unicode property value (see constants above) of the -// given code point. -func property(dictionary [][3]int, r rune) int { - return propertySearch(dictionary, r)[2] -} - -// propertyLineBreak returns the Unicode property value and General Category -// (see constants above) of the given code point, as listed in the line break -// code points table, while fast tracking ASCII digits and letters. -func propertyLineBreak(r rune) (property, generalCategory int) { - if r >= 'a' && r <= 'z' { - return prAL, gcLl - } - if r >= 'A' && r <= 'Z' { - return prAL, gcLu - } - if r >= '0' && r <= '9' { - return prNU, gcNd - } - entry := propertySearch(lineBreakCodePoints, r) - return entry[2], entry[3] -} - -// propertyGraphemes returns the Unicode grapheme cluster property value of the -// given code point while fast tracking ASCII characters. -func propertyGraphemes(r rune) int { - if r >= 0x20 && r <= 0x7e { - return prAny - } - if r == 0x0a { - return prLF - } - if r == 0x0d { - return prCR - } - if r >= 0 && r <= 0x1f || r == 0x7f { - return prControl - } - return property(graphemeCodePoints, r) -} - -// propertyEastAsianWidth returns the Unicode East Asian Width property value of -// the given code point while fast tracking ASCII characters. -func propertyEastAsianWidth(r rune) int { - if r >= 0x20 && r <= 0x7e { - return prNa - } - if r >= 0 && r <= 0x1f || r == 0x7f { - return prN - } - return property(eastAsianWidth, r) -} diff --git a/vendor/github.com/rivo/uniseg/sentence.go b/vendor/github.com/rivo/uniseg/sentence.go deleted file mode 100644 index adc2a35..0000000 --- a/vendor/github.com/rivo/uniseg/sentence.go +++ /dev/null @@ -1,90 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// FirstSentence returns the first sentence found in the given byte slice -// according to the rules of [Unicode Standard Annex #29, Sentence Boundaries]. -// This function can be called continuously to extract all sentences from a byte -// slice, as illustrated in the example below. -// -// If you don't know the current state, for example when calling the function -// for the first time, you must pass -1. For consecutive calls, pass the state -// and rest slice returned by the previous call. -// -// The "rest" slice is the sub-slice of the original byte slice "b" starting -// after the last byte of the identified sentence. If the length of the "rest" -// slice is 0, the entire byte slice "b" has been processed. The "sentence" byte -// slice is the sub-slice of the input slice containing the identified sentence. -// -// Given an empty byte slice "b", the function returns nil values. -// -// [Unicode Standard Annex #29, Sentence Boundaries]: http://unicode.org/reports/tr29/#Sentence_Boundaries -func FirstSentence(b []byte, state int) (sentence, rest []byte, newState int) { - // An empty byte slice returns nothing. - if len(b) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRune(b) - if len(b) <= length { // If we're already past the end, there is nothing else to parse. - return b, nil, sbAny - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionSentenceBreakState(state, r, b[length:], "") - } - - // Transition until we find a boundary. - var boundary bool - for { - r, l := utf8.DecodeRune(b[length:]) - state, boundary = transitionSentenceBreakState(state, r, b[length+l:], "") - - if boundary { - return b[:length], b[length:], state - } - - length += l - if len(b) <= length { - return b, nil, sbAny - } - } -} - -// FirstSentenceInString is like [FirstSentence] but its input and outputs are -// strings. -func FirstSentenceInString(str string, state int) (sentence, rest string, newState int) { - // An empty byte slice returns nothing. - if len(str) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRuneInString(str) - if len(str) <= length { // If we're already past the end, there is nothing else to parse. - return str, "", sbAny - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionSentenceBreakState(state, r, nil, str[length:]) - } - - // Transition until we find a boundary. - var boundary bool - for { - r, l := utf8.DecodeRuneInString(str[length:]) - state, boundary = transitionSentenceBreakState(state, r, nil, str[length+l:]) - - if boundary { - return str[:length], str[length:], state - } - - length += l - if len(str) <= length { - return str, "", sbAny - } - } -} diff --git a/vendor/github.com/rivo/uniseg/sentenceproperties.go b/vendor/github.com/rivo/uniseg/sentenceproperties.go deleted file mode 100644 index 67717ec..0000000 --- a/vendor/github.com/rivo/uniseg/sentenceproperties.go +++ /dev/null @@ -1,2845 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// sentenceBreakCodePoints are taken from -// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/SentenceBreakProperty.txt -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var sentenceBreakCodePoints = [][3]int{ - {0x0009, 0x0009, prSp}, // Cc - {0x000A, 0x000A, prLF}, // Cc - {0x000B, 0x000C, prSp}, // Cc [2] .. - {0x000D, 0x000D, prCR}, // Cc - {0x0020, 0x0020, prSp}, // Zs SPACE - {0x0021, 0x0021, prSTerm}, // Po EXCLAMATION MARK - {0x0022, 0x0022, prClose}, // Po QUOTATION MARK - {0x0027, 0x0027, prClose}, // Po APOSTROPHE - {0x0028, 0x0028, prClose}, // Ps LEFT PARENTHESIS - {0x0029, 0x0029, prClose}, // Pe RIGHT PARENTHESIS - {0x002C, 0x002C, prSContinue}, // Po COMMA - {0x002D, 0x002D, prSContinue}, // Pd HYPHEN-MINUS - {0x002E, 0x002E, prATerm}, // Po FULL STOP - {0x0030, 0x0039, prNumeric}, // Nd [10] DIGIT ZERO..DIGIT NINE - {0x003A, 0x003A, prSContinue}, // Po COLON - {0x003F, 0x003F, prSTerm}, // Po QUESTION MARK - {0x0041, 0x005A, prUpper}, // L& [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z - {0x005B, 0x005B, prClose}, // Ps LEFT SQUARE BRACKET - {0x005D, 0x005D, prClose}, // Pe RIGHT SQUARE BRACKET - {0x0061, 0x007A, prLower}, // L& [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z - {0x007B, 0x007B, prClose}, // Ps LEFT CURLY BRACKET - {0x007D, 0x007D, prClose}, // Pe RIGHT CURLY BRACKET - {0x0085, 0x0085, prSep}, // Cc - {0x00A0, 0x00A0, prSp}, // Zs NO-BREAK SPACE - {0x00AA, 0x00AA, prLower}, // Lo FEMININE ORDINAL INDICATOR - {0x00AB, 0x00AB, prClose}, // Pi LEFT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00AD, 0x00AD, prFormat}, // Cf SOFT HYPHEN - {0x00B5, 0x00B5, prLower}, // L& MICRO SIGN - {0x00BA, 0x00BA, prLower}, // Lo MASCULINE ORDINAL INDICATOR - {0x00BB, 0x00BB, prClose}, // Pf RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK - {0x00C0, 0x00D6, prUpper}, // L& [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS - {0x00D8, 0x00DE, prUpper}, // L& [7] LATIN CAPITAL LETTER O WITH STROKE..LATIN CAPITAL LETTER THORN - {0x00DF, 0x00F6, prLower}, // L& [24] LATIN SMALL LETTER SHARP S..LATIN SMALL LETTER O WITH DIAERESIS - {0x00F8, 0x00FF, prLower}, // L& [8] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER Y WITH DIAERESIS - {0x0100, 0x0100, prUpper}, // L& LATIN CAPITAL LETTER A WITH MACRON - {0x0101, 0x0101, prLower}, // L& LATIN SMALL LETTER A WITH MACRON - {0x0102, 0x0102, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE - {0x0103, 0x0103, prLower}, // L& LATIN SMALL LETTER A WITH BREVE - {0x0104, 0x0104, prUpper}, // L& LATIN CAPITAL LETTER A WITH OGONEK - {0x0105, 0x0105, prLower}, // L& LATIN SMALL LETTER A WITH OGONEK - {0x0106, 0x0106, prUpper}, // L& LATIN CAPITAL LETTER C WITH ACUTE - {0x0107, 0x0107, prLower}, // L& LATIN SMALL LETTER C WITH ACUTE - {0x0108, 0x0108, prUpper}, // L& LATIN CAPITAL LETTER C WITH CIRCUMFLEX - {0x0109, 0x0109, prLower}, // L& LATIN SMALL LETTER C WITH CIRCUMFLEX - {0x010A, 0x010A, prUpper}, // L& LATIN CAPITAL LETTER C WITH DOT ABOVE - {0x010B, 0x010B, prLower}, // L& LATIN SMALL LETTER C WITH DOT ABOVE - {0x010C, 0x010C, prUpper}, // L& LATIN CAPITAL LETTER C WITH CARON - {0x010D, 0x010D, prLower}, // L& LATIN SMALL LETTER C WITH CARON - {0x010E, 0x010E, prUpper}, // L& LATIN CAPITAL LETTER D WITH CARON - {0x010F, 0x010F, prLower}, // L& LATIN SMALL LETTER D WITH CARON - {0x0110, 0x0110, prUpper}, // L& LATIN CAPITAL LETTER D WITH STROKE - {0x0111, 0x0111, prLower}, // L& LATIN SMALL LETTER D WITH STROKE - {0x0112, 0x0112, prUpper}, // L& LATIN CAPITAL LETTER E WITH MACRON - {0x0113, 0x0113, prLower}, // L& LATIN SMALL LETTER E WITH MACRON - {0x0114, 0x0114, prUpper}, // L& LATIN CAPITAL LETTER E WITH BREVE - {0x0115, 0x0115, prLower}, // L& LATIN SMALL LETTER E WITH BREVE - {0x0116, 0x0116, prUpper}, // L& LATIN CAPITAL LETTER E WITH DOT ABOVE - {0x0117, 0x0117, prLower}, // L& LATIN SMALL LETTER E WITH DOT ABOVE - {0x0118, 0x0118, prUpper}, // L& LATIN CAPITAL LETTER E WITH OGONEK - {0x0119, 0x0119, prLower}, // L& LATIN SMALL LETTER E WITH OGONEK - {0x011A, 0x011A, prUpper}, // L& LATIN CAPITAL LETTER E WITH CARON - {0x011B, 0x011B, prLower}, // L& LATIN SMALL LETTER E WITH CARON - {0x011C, 0x011C, prUpper}, // L& LATIN CAPITAL LETTER G WITH CIRCUMFLEX - {0x011D, 0x011D, prLower}, // L& LATIN SMALL LETTER G WITH CIRCUMFLEX - {0x011E, 0x011E, prUpper}, // L& LATIN CAPITAL LETTER G WITH BREVE - {0x011F, 0x011F, prLower}, // L& LATIN SMALL LETTER G WITH BREVE - {0x0120, 0x0120, prUpper}, // L& LATIN CAPITAL LETTER G WITH DOT ABOVE - {0x0121, 0x0121, prLower}, // L& LATIN SMALL LETTER G WITH DOT ABOVE - {0x0122, 0x0122, prUpper}, // L& LATIN CAPITAL LETTER G WITH CEDILLA - {0x0123, 0x0123, prLower}, // L& LATIN SMALL LETTER G WITH CEDILLA - {0x0124, 0x0124, prUpper}, // L& LATIN CAPITAL LETTER H WITH CIRCUMFLEX - {0x0125, 0x0125, prLower}, // L& LATIN SMALL LETTER H WITH CIRCUMFLEX - {0x0126, 0x0126, prUpper}, // L& LATIN CAPITAL LETTER H WITH STROKE - {0x0127, 0x0127, prLower}, // L& LATIN SMALL LETTER H WITH STROKE - {0x0128, 0x0128, prUpper}, // L& LATIN CAPITAL LETTER I WITH TILDE - {0x0129, 0x0129, prLower}, // L& LATIN SMALL LETTER I WITH TILDE - {0x012A, 0x012A, prUpper}, // L& LATIN CAPITAL LETTER I WITH MACRON - {0x012B, 0x012B, prLower}, // L& LATIN SMALL LETTER I WITH MACRON - {0x012C, 0x012C, prUpper}, // L& LATIN CAPITAL LETTER I WITH BREVE - {0x012D, 0x012D, prLower}, // L& LATIN SMALL LETTER I WITH BREVE - {0x012E, 0x012E, prUpper}, // L& LATIN CAPITAL LETTER I WITH OGONEK - {0x012F, 0x012F, prLower}, // L& LATIN SMALL LETTER I WITH OGONEK - {0x0130, 0x0130, prUpper}, // L& LATIN CAPITAL LETTER I WITH DOT ABOVE - {0x0131, 0x0131, prLower}, // L& LATIN SMALL LETTER DOTLESS I - {0x0132, 0x0132, prUpper}, // L& LATIN CAPITAL LIGATURE IJ - {0x0133, 0x0133, prLower}, // L& LATIN SMALL LIGATURE IJ - {0x0134, 0x0134, prUpper}, // L& LATIN CAPITAL LETTER J WITH CIRCUMFLEX - {0x0135, 0x0135, prLower}, // L& LATIN SMALL LETTER J WITH CIRCUMFLEX - {0x0136, 0x0136, prUpper}, // L& LATIN CAPITAL LETTER K WITH CEDILLA - {0x0137, 0x0138, prLower}, // L& [2] LATIN SMALL LETTER K WITH CEDILLA..LATIN SMALL LETTER KRA - {0x0139, 0x0139, prUpper}, // L& LATIN CAPITAL LETTER L WITH ACUTE - {0x013A, 0x013A, prLower}, // L& LATIN SMALL LETTER L WITH ACUTE - {0x013B, 0x013B, prUpper}, // L& LATIN CAPITAL LETTER L WITH CEDILLA - {0x013C, 0x013C, prLower}, // L& LATIN SMALL LETTER L WITH CEDILLA - {0x013D, 0x013D, prUpper}, // L& LATIN CAPITAL LETTER L WITH CARON - {0x013E, 0x013E, prLower}, // L& LATIN SMALL LETTER L WITH CARON - {0x013F, 0x013F, prUpper}, // L& LATIN CAPITAL LETTER L WITH MIDDLE DOT - {0x0140, 0x0140, prLower}, // L& LATIN SMALL LETTER L WITH MIDDLE DOT - {0x0141, 0x0141, prUpper}, // L& LATIN CAPITAL LETTER L WITH STROKE - {0x0142, 0x0142, prLower}, // L& LATIN SMALL LETTER L WITH STROKE - {0x0143, 0x0143, prUpper}, // L& LATIN CAPITAL LETTER N WITH ACUTE - {0x0144, 0x0144, prLower}, // L& LATIN SMALL LETTER N WITH ACUTE - {0x0145, 0x0145, prUpper}, // L& LATIN CAPITAL LETTER N WITH CEDILLA - {0x0146, 0x0146, prLower}, // L& LATIN SMALL LETTER N WITH CEDILLA - {0x0147, 0x0147, prUpper}, // L& LATIN CAPITAL LETTER N WITH CARON - {0x0148, 0x0149, prLower}, // L& [2] LATIN SMALL LETTER N WITH CARON..LATIN SMALL LETTER N PRECEDED BY APOSTROPHE - {0x014A, 0x014A, prUpper}, // L& LATIN CAPITAL LETTER ENG - {0x014B, 0x014B, prLower}, // L& LATIN SMALL LETTER ENG - {0x014C, 0x014C, prUpper}, // L& LATIN CAPITAL LETTER O WITH MACRON - {0x014D, 0x014D, prLower}, // L& LATIN SMALL LETTER O WITH MACRON - {0x014E, 0x014E, prUpper}, // L& LATIN CAPITAL LETTER O WITH BREVE - {0x014F, 0x014F, prLower}, // L& LATIN SMALL LETTER O WITH BREVE - {0x0150, 0x0150, prUpper}, // L& LATIN CAPITAL LETTER O WITH DOUBLE ACUTE - {0x0151, 0x0151, prLower}, // L& LATIN SMALL LETTER O WITH DOUBLE ACUTE - {0x0152, 0x0152, prUpper}, // L& LATIN CAPITAL LIGATURE OE - {0x0153, 0x0153, prLower}, // L& LATIN SMALL LIGATURE OE - {0x0154, 0x0154, prUpper}, // L& LATIN CAPITAL LETTER R WITH ACUTE - {0x0155, 0x0155, prLower}, // L& LATIN SMALL LETTER R WITH ACUTE - {0x0156, 0x0156, prUpper}, // L& LATIN CAPITAL LETTER R WITH CEDILLA - {0x0157, 0x0157, prLower}, // L& LATIN SMALL LETTER R WITH CEDILLA - {0x0158, 0x0158, prUpper}, // L& LATIN CAPITAL LETTER R WITH CARON - {0x0159, 0x0159, prLower}, // L& LATIN SMALL LETTER R WITH CARON - {0x015A, 0x015A, prUpper}, // L& LATIN CAPITAL LETTER S WITH ACUTE - {0x015B, 0x015B, prLower}, // L& LATIN SMALL LETTER S WITH ACUTE - {0x015C, 0x015C, prUpper}, // L& LATIN CAPITAL LETTER S WITH CIRCUMFLEX - {0x015D, 0x015D, prLower}, // L& LATIN SMALL LETTER S WITH CIRCUMFLEX - {0x015E, 0x015E, prUpper}, // L& LATIN CAPITAL LETTER S WITH CEDILLA - {0x015F, 0x015F, prLower}, // L& LATIN SMALL LETTER S WITH CEDILLA - {0x0160, 0x0160, prUpper}, // L& LATIN CAPITAL LETTER S WITH CARON - {0x0161, 0x0161, prLower}, // L& LATIN SMALL LETTER S WITH CARON - {0x0162, 0x0162, prUpper}, // L& LATIN CAPITAL LETTER T WITH CEDILLA - {0x0163, 0x0163, prLower}, // L& LATIN SMALL LETTER T WITH CEDILLA - {0x0164, 0x0164, prUpper}, // L& LATIN CAPITAL LETTER T WITH CARON - {0x0165, 0x0165, prLower}, // L& LATIN SMALL LETTER T WITH CARON - {0x0166, 0x0166, prUpper}, // L& LATIN CAPITAL LETTER T WITH STROKE - {0x0167, 0x0167, prLower}, // L& LATIN SMALL LETTER T WITH STROKE - {0x0168, 0x0168, prUpper}, // L& LATIN CAPITAL LETTER U WITH TILDE - {0x0169, 0x0169, prLower}, // L& LATIN SMALL LETTER U WITH TILDE - {0x016A, 0x016A, prUpper}, // L& LATIN CAPITAL LETTER U WITH MACRON - {0x016B, 0x016B, prLower}, // L& LATIN SMALL LETTER U WITH MACRON - {0x016C, 0x016C, prUpper}, // L& LATIN CAPITAL LETTER U WITH BREVE - {0x016D, 0x016D, prLower}, // L& LATIN SMALL LETTER U WITH BREVE - {0x016E, 0x016E, prUpper}, // L& LATIN CAPITAL LETTER U WITH RING ABOVE - {0x016F, 0x016F, prLower}, // L& LATIN SMALL LETTER U WITH RING ABOVE - {0x0170, 0x0170, prUpper}, // L& LATIN CAPITAL LETTER U WITH DOUBLE ACUTE - {0x0171, 0x0171, prLower}, // L& LATIN SMALL LETTER U WITH DOUBLE ACUTE - {0x0172, 0x0172, prUpper}, // L& LATIN CAPITAL LETTER U WITH OGONEK - {0x0173, 0x0173, prLower}, // L& LATIN SMALL LETTER U WITH OGONEK - {0x0174, 0x0174, prUpper}, // L& LATIN CAPITAL LETTER W WITH CIRCUMFLEX - {0x0175, 0x0175, prLower}, // L& LATIN SMALL LETTER W WITH CIRCUMFLEX - {0x0176, 0x0176, prUpper}, // L& LATIN CAPITAL LETTER Y WITH CIRCUMFLEX - {0x0177, 0x0177, prLower}, // L& LATIN SMALL LETTER Y WITH CIRCUMFLEX - {0x0178, 0x0179, prUpper}, // L& [2] LATIN CAPITAL LETTER Y WITH DIAERESIS..LATIN CAPITAL LETTER Z WITH ACUTE - {0x017A, 0x017A, prLower}, // L& LATIN SMALL LETTER Z WITH ACUTE - {0x017B, 0x017B, prUpper}, // L& LATIN CAPITAL LETTER Z WITH DOT ABOVE - {0x017C, 0x017C, prLower}, // L& LATIN SMALL LETTER Z WITH DOT ABOVE - {0x017D, 0x017D, prUpper}, // L& LATIN CAPITAL LETTER Z WITH CARON - {0x017E, 0x0180, prLower}, // L& [3] LATIN SMALL LETTER Z WITH CARON..LATIN SMALL LETTER B WITH STROKE - {0x0181, 0x0182, prUpper}, // L& [2] LATIN CAPITAL LETTER B WITH HOOK..LATIN CAPITAL LETTER B WITH TOPBAR - {0x0183, 0x0183, prLower}, // L& LATIN SMALL LETTER B WITH TOPBAR - {0x0184, 0x0184, prUpper}, // L& LATIN CAPITAL LETTER TONE SIX - {0x0185, 0x0185, prLower}, // L& LATIN SMALL LETTER TONE SIX - {0x0186, 0x0187, prUpper}, // L& [2] LATIN CAPITAL LETTER OPEN O..LATIN CAPITAL LETTER C WITH HOOK - {0x0188, 0x0188, prLower}, // L& LATIN SMALL LETTER C WITH HOOK - {0x0189, 0x018B, prUpper}, // L& [3] LATIN CAPITAL LETTER AFRICAN D..LATIN CAPITAL LETTER D WITH TOPBAR - {0x018C, 0x018D, prLower}, // L& [2] LATIN SMALL LETTER D WITH TOPBAR..LATIN SMALL LETTER TURNED DELTA - {0x018E, 0x0191, prUpper}, // L& [4] LATIN CAPITAL LETTER REVERSED E..LATIN CAPITAL LETTER F WITH HOOK - {0x0192, 0x0192, prLower}, // L& LATIN SMALL LETTER F WITH HOOK - {0x0193, 0x0194, prUpper}, // L& [2] LATIN CAPITAL LETTER G WITH HOOK..LATIN CAPITAL LETTER GAMMA - {0x0195, 0x0195, prLower}, // L& LATIN SMALL LETTER HV - {0x0196, 0x0198, prUpper}, // L& [3] LATIN CAPITAL LETTER IOTA..LATIN CAPITAL LETTER K WITH HOOK - {0x0199, 0x019B, prLower}, // L& [3] LATIN SMALL LETTER K WITH HOOK..LATIN SMALL LETTER LAMBDA WITH STROKE - {0x019C, 0x019D, prUpper}, // L& [2] LATIN CAPITAL LETTER TURNED M..LATIN CAPITAL LETTER N WITH LEFT HOOK - {0x019E, 0x019E, prLower}, // L& LATIN SMALL LETTER N WITH LONG RIGHT LEG - {0x019F, 0x01A0, prUpper}, // L& [2] LATIN CAPITAL LETTER O WITH MIDDLE TILDE..LATIN CAPITAL LETTER O WITH HORN - {0x01A1, 0x01A1, prLower}, // L& LATIN SMALL LETTER O WITH HORN - {0x01A2, 0x01A2, prUpper}, // L& LATIN CAPITAL LETTER OI - {0x01A3, 0x01A3, prLower}, // L& LATIN SMALL LETTER OI - {0x01A4, 0x01A4, prUpper}, // L& LATIN CAPITAL LETTER P WITH HOOK - {0x01A5, 0x01A5, prLower}, // L& LATIN SMALL LETTER P WITH HOOK - {0x01A6, 0x01A7, prUpper}, // L& [2] LATIN LETTER YR..LATIN CAPITAL LETTER TONE TWO - {0x01A8, 0x01A8, prLower}, // L& LATIN SMALL LETTER TONE TWO - {0x01A9, 0x01A9, prUpper}, // L& LATIN CAPITAL LETTER ESH - {0x01AA, 0x01AB, prLower}, // L& [2] LATIN LETTER REVERSED ESH LOOP..LATIN SMALL LETTER T WITH PALATAL HOOK - {0x01AC, 0x01AC, prUpper}, // L& LATIN CAPITAL LETTER T WITH HOOK - {0x01AD, 0x01AD, prLower}, // L& LATIN SMALL LETTER T WITH HOOK - {0x01AE, 0x01AF, prUpper}, // L& [2] LATIN CAPITAL LETTER T WITH RETROFLEX HOOK..LATIN CAPITAL LETTER U WITH HORN - {0x01B0, 0x01B0, prLower}, // L& LATIN SMALL LETTER U WITH HORN - {0x01B1, 0x01B3, prUpper}, // L& [3] LATIN CAPITAL LETTER UPSILON..LATIN CAPITAL LETTER Y WITH HOOK - {0x01B4, 0x01B4, prLower}, // L& LATIN SMALL LETTER Y WITH HOOK - {0x01B5, 0x01B5, prUpper}, // L& LATIN CAPITAL LETTER Z WITH STROKE - {0x01B6, 0x01B6, prLower}, // L& LATIN SMALL LETTER Z WITH STROKE - {0x01B7, 0x01B8, prUpper}, // L& [2] LATIN CAPITAL LETTER EZH..LATIN CAPITAL LETTER EZH REVERSED - {0x01B9, 0x01BA, prLower}, // L& [2] LATIN SMALL LETTER EZH REVERSED..LATIN SMALL LETTER EZH WITH TAIL - {0x01BB, 0x01BB, prOLetter}, // Lo LATIN LETTER TWO WITH STROKE - {0x01BC, 0x01BC, prUpper}, // L& LATIN CAPITAL LETTER TONE FIVE - {0x01BD, 0x01BF, prLower}, // L& [3] LATIN SMALL LETTER TONE FIVE..LATIN LETTER WYNN - {0x01C0, 0x01C3, prOLetter}, // Lo [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK - {0x01C4, 0x01C5, prUpper}, // L& [2] LATIN CAPITAL LETTER DZ WITH CARON..LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON - {0x01C6, 0x01C6, prLower}, // L& LATIN SMALL LETTER DZ WITH CARON - {0x01C7, 0x01C8, prUpper}, // L& [2] LATIN CAPITAL LETTER LJ..LATIN CAPITAL LETTER L WITH SMALL LETTER J - {0x01C9, 0x01C9, prLower}, // L& LATIN SMALL LETTER LJ - {0x01CA, 0x01CB, prUpper}, // L& [2] LATIN CAPITAL LETTER NJ..LATIN CAPITAL LETTER N WITH SMALL LETTER J - {0x01CC, 0x01CC, prLower}, // L& LATIN SMALL LETTER NJ - {0x01CD, 0x01CD, prUpper}, // L& LATIN CAPITAL LETTER A WITH CARON - {0x01CE, 0x01CE, prLower}, // L& LATIN SMALL LETTER A WITH CARON - {0x01CF, 0x01CF, prUpper}, // L& LATIN CAPITAL LETTER I WITH CARON - {0x01D0, 0x01D0, prLower}, // L& LATIN SMALL LETTER I WITH CARON - {0x01D1, 0x01D1, prUpper}, // L& LATIN CAPITAL LETTER O WITH CARON - {0x01D2, 0x01D2, prLower}, // L& LATIN SMALL LETTER O WITH CARON - {0x01D3, 0x01D3, prUpper}, // L& LATIN CAPITAL LETTER U WITH CARON - {0x01D4, 0x01D4, prLower}, // L& LATIN SMALL LETTER U WITH CARON - {0x01D5, 0x01D5, prUpper}, // L& LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON - {0x01D6, 0x01D6, prLower}, // L& LATIN SMALL LETTER U WITH DIAERESIS AND MACRON - {0x01D7, 0x01D7, prUpper}, // L& LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE - {0x01D8, 0x01D8, prLower}, // L& LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE - {0x01D9, 0x01D9, prUpper}, // L& LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON - {0x01DA, 0x01DA, prLower}, // L& LATIN SMALL LETTER U WITH DIAERESIS AND CARON - {0x01DB, 0x01DB, prUpper}, // L& LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE - {0x01DC, 0x01DD, prLower}, // L& [2] LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE..LATIN SMALL LETTER TURNED E - {0x01DE, 0x01DE, prUpper}, // L& LATIN CAPITAL LETTER A WITH DIAERESIS AND MACRON - {0x01DF, 0x01DF, prLower}, // L& LATIN SMALL LETTER A WITH DIAERESIS AND MACRON - {0x01E0, 0x01E0, prUpper}, // L& LATIN CAPITAL LETTER A WITH DOT ABOVE AND MACRON - {0x01E1, 0x01E1, prLower}, // L& LATIN SMALL LETTER A WITH DOT ABOVE AND MACRON - {0x01E2, 0x01E2, prUpper}, // L& LATIN CAPITAL LETTER AE WITH MACRON - {0x01E3, 0x01E3, prLower}, // L& LATIN SMALL LETTER AE WITH MACRON - {0x01E4, 0x01E4, prUpper}, // L& LATIN CAPITAL LETTER G WITH STROKE - {0x01E5, 0x01E5, prLower}, // L& LATIN SMALL LETTER G WITH STROKE - {0x01E6, 0x01E6, prUpper}, // L& LATIN CAPITAL LETTER G WITH CARON - {0x01E7, 0x01E7, prLower}, // L& LATIN SMALL LETTER G WITH CARON - {0x01E8, 0x01E8, prUpper}, // L& LATIN CAPITAL LETTER K WITH CARON - {0x01E9, 0x01E9, prLower}, // L& LATIN SMALL LETTER K WITH CARON - {0x01EA, 0x01EA, prUpper}, // L& LATIN CAPITAL LETTER O WITH OGONEK - {0x01EB, 0x01EB, prLower}, // L& LATIN SMALL LETTER O WITH OGONEK - {0x01EC, 0x01EC, prUpper}, // L& LATIN CAPITAL LETTER O WITH OGONEK AND MACRON - {0x01ED, 0x01ED, prLower}, // L& LATIN SMALL LETTER O WITH OGONEK AND MACRON - {0x01EE, 0x01EE, prUpper}, // L& LATIN CAPITAL LETTER EZH WITH CARON - {0x01EF, 0x01F0, prLower}, // L& [2] LATIN SMALL LETTER EZH WITH CARON..LATIN SMALL LETTER J WITH CARON - {0x01F1, 0x01F2, prUpper}, // L& [2] LATIN CAPITAL LETTER DZ..LATIN CAPITAL LETTER D WITH SMALL LETTER Z - {0x01F3, 0x01F3, prLower}, // L& LATIN SMALL LETTER DZ - {0x01F4, 0x01F4, prUpper}, // L& LATIN CAPITAL LETTER G WITH ACUTE - {0x01F5, 0x01F5, prLower}, // L& LATIN SMALL LETTER G WITH ACUTE - {0x01F6, 0x01F8, prUpper}, // L& [3] LATIN CAPITAL LETTER HWAIR..LATIN CAPITAL LETTER N WITH GRAVE - {0x01F9, 0x01F9, prLower}, // L& LATIN SMALL LETTER N WITH GRAVE - {0x01FA, 0x01FA, prUpper}, // L& LATIN CAPITAL LETTER A WITH RING ABOVE AND ACUTE - {0x01FB, 0x01FB, prLower}, // L& LATIN SMALL LETTER A WITH RING ABOVE AND ACUTE - {0x01FC, 0x01FC, prUpper}, // L& LATIN CAPITAL LETTER AE WITH ACUTE - {0x01FD, 0x01FD, prLower}, // L& LATIN SMALL LETTER AE WITH ACUTE - {0x01FE, 0x01FE, prUpper}, // L& LATIN CAPITAL LETTER O WITH STROKE AND ACUTE - {0x01FF, 0x01FF, prLower}, // L& LATIN SMALL LETTER O WITH STROKE AND ACUTE - {0x0200, 0x0200, prUpper}, // L& LATIN CAPITAL LETTER A WITH DOUBLE GRAVE - {0x0201, 0x0201, prLower}, // L& LATIN SMALL LETTER A WITH DOUBLE GRAVE - {0x0202, 0x0202, prUpper}, // L& LATIN CAPITAL LETTER A WITH INVERTED BREVE - {0x0203, 0x0203, prLower}, // L& LATIN SMALL LETTER A WITH INVERTED BREVE - {0x0204, 0x0204, prUpper}, // L& LATIN CAPITAL LETTER E WITH DOUBLE GRAVE - {0x0205, 0x0205, prLower}, // L& LATIN SMALL LETTER E WITH DOUBLE GRAVE - {0x0206, 0x0206, prUpper}, // L& LATIN CAPITAL LETTER E WITH INVERTED BREVE - {0x0207, 0x0207, prLower}, // L& LATIN SMALL LETTER E WITH INVERTED BREVE - {0x0208, 0x0208, prUpper}, // L& LATIN CAPITAL LETTER I WITH DOUBLE GRAVE - {0x0209, 0x0209, prLower}, // L& LATIN SMALL LETTER I WITH DOUBLE GRAVE - {0x020A, 0x020A, prUpper}, // L& LATIN CAPITAL LETTER I WITH INVERTED BREVE - {0x020B, 0x020B, prLower}, // L& LATIN SMALL LETTER I WITH INVERTED BREVE - {0x020C, 0x020C, prUpper}, // L& LATIN CAPITAL LETTER O WITH DOUBLE GRAVE - {0x020D, 0x020D, prLower}, // L& LATIN SMALL LETTER O WITH DOUBLE GRAVE - {0x020E, 0x020E, prUpper}, // L& LATIN CAPITAL LETTER O WITH INVERTED BREVE - {0x020F, 0x020F, prLower}, // L& LATIN SMALL LETTER O WITH INVERTED BREVE - {0x0210, 0x0210, prUpper}, // L& LATIN CAPITAL LETTER R WITH DOUBLE GRAVE - {0x0211, 0x0211, prLower}, // L& LATIN SMALL LETTER R WITH DOUBLE GRAVE - {0x0212, 0x0212, prUpper}, // L& LATIN CAPITAL LETTER R WITH INVERTED BREVE - {0x0213, 0x0213, prLower}, // L& LATIN SMALL LETTER R WITH INVERTED BREVE - {0x0214, 0x0214, prUpper}, // L& LATIN CAPITAL LETTER U WITH DOUBLE GRAVE - {0x0215, 0x0215, prLower}, // L& LATIN SMALL LETTER U WITH DOUBLE GRAVE - {0x0216, 0x0216, prUpper}, // L& LATIN CAPITAL LETTER U WITH INVERTED BREVE - {0x0217, 0x0217, prLower}, // L& LATIN SMALL LETTER U WITH INVERTED BREVE - {0x0218, 0x0218, prUpper}, // L& LATIN CAPITAL LETTER S WITH COMMA BELOW - {0x0219, 0x0219, prLower}, // L& LATIN SMALL LETTER S WITH COMMA BELOW - {0x021A, 0x021A, prUpper}, // L& LATIN CAPITAL LETTER T WITH COMMA BELOW - {0x021B, 0x021B, prLower}, // L& LATIN SMALL LETTER T WITH COMMA BELOW - {0x021C, 0x021C, prUpper}, // L& LATIN CAPITAL LETTER YOGH - {0x021D, 0x021D, prLower}, // L& LATIN SMALL LETTER YOGH - {0x021E, 0x021E, prUpper}, // L& LATIN CAPITAL LETTER H WITH CARON - {0x021F, 0x021F, prLower}, // L& LATIN SMALL LETTER H WITH CARON - {0x0220, 0x0220, prUpper}, // L& LATIN CAPITAL LETTER N WITH LONG RIGHT LEG - {0x0221, 0x0221, prLower}, // L& LATIN SMALL LETTER D WITH CURL - {0x0222, 0x0222, prUpper}, // L& LATIN CAPITAL LETTER OU - {0x0223, 0x0223, prLower}, // L& LATIN SMALL LETTER OU - {0x0224, 0x0224, prUpper}, // L& LATIN CAPITAL LETTER Z WITH HOOK - {0x0225, 0x0225, prLower}, // L& LATIN SMALL LETTER Z WITH HOOK - {0x0226, 0x0226, prUpper}, // L& LATIN CAPITAL LETTER A WITH DOT ABOVE - {0x0227, 0x0227, prLower}, // L& LATIN SMALL LETTER A WITH DOT ABOVE - {0x0228, 0x0228, prUpper}, // L& LATIN CAPITAL LETTER E WITH CEDILLA - {0x0229, 0x0229, prLower}, // L& LATIN SMALL LETTER E WITH CEDILLA - {0x022A, 0x022A, prUpper}, // L& LATIN CAPITAL LETTER O WITH DIAERESIS AND MACRON - {0x022B, 0x022B, prLower}, // L& LATIN SMALL LETTER O WITH DIAERESIS AND MACRON - {0x022C, 0x022C, prUpper}, // L& LATIN CAPITAL LETTER O WITH TILDE AND MACRON - {0x022D, 0x022D, prLower}, // L& LATIN SMALL LETTER O WITH TILDE AND MACRON - {0x022E, 0x022E, prUpper}, // L& LATIN CAPITAL LETTER O WITH DOT ABOVE - {0x022F, 0x022F, prLower}, // L& LATIN SMALL LETTER O WITH DOT ABOVE - {0x0230, 0x0230, prUpper}, // L& LATIN CAPITAL LETTER O WITH DOT ABOVE AND MACRON - {0x0231, 0x0231, prLower}, // L& LATIN SMALL LETTER O WITH DOT ABOVE AND MACRON - {0x0232, 0x0232, prUpper}, // L& LATIN CAPITAL LETTER Y WITH MACRON - {0x0233, 0x0239, prLower}, // L& [7] LATIN SMALL LETTER Y WITH MACRON..LATIN SMALL LETTER QP DIGRAPH - {0x023A, 0x023B, prUpper}, // L& [2] LATIN CAPITAL LETTER A WITH STROKE..LATIN CAPITAL LETTER C WITH STROKE - {0x023C, 0x023C, prLower}, // L& LATIN SMALL LETTER C WITH STROKE - {0x023D, 0x023E, prUpper}, // L& [2] LATIN CAPITAL LETTER L WITH BAR..LATIN CAPITAL LETTER T WITH DIAGONAL STROKE - {0x023F, 0x0240, prLower}, // L& [2] LATIN SMALL LETTER S WITH SWASH TAIL..LATIN SMALL LETTER Z WITH SWASH TAIL - {0x0241, 0x0241, prUpper}, // L& LATIN CAPITAL LETTER GLOTTAL STOP - {0x0242, 0x0242, prLower}, // L& LATIN SMALL LETTER GLOTTAL STOP - {0x0243, 0x0246, prUpper}, // L& [4] LATIN CAPITAL LETTER B WITH STROKE..LATIN CAPITAL LETTER E WITH STROKE - {0x0247, 0x0247, prLower}, // L& LATIN SMALL LETTER E WITH STROKE - {0x0248, 0x0248, prUpper}, // L& LATIN CAPITAL LETTER J WITH STROKE - {0x0249, 0x0249, prLower}, // L& LATIN SMALL LETTER J WITH STROKE - {0x024A, 0x024A, prUpper}, // L& LATIN CAPITAL LETTER SMALL Q WITH HOOK TAIL - {0x024B, 0x024B, prLower}, // L& LATIN SMALL LETTER Q WITH HOOK TAIL - {0x024C, 0x024C, prUpper}, // L& LATIN CAPITAL LETTER R WITH STROKE - {0x024D, 0x024D, prLower}, // L& LATIN SMALL LETTER R WITH STROKE - {0x024E, 0x024E, prUpper}, // L& LATIN CAPITAL LETTER Y WITH STROKE - {0x024F, 0x0293, prLower}, // L& [69] LATIN SMALL LETTER Y WITH STROKE..LATIN SMALL LETTER EZH WITH CURL - {0x0294, 0x0294, prOLetter}, // Lo LATIN LETTER GLOTTAL STOP - {0x0295, 0x02AF, prLower}, // L& [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL - {0x02B0, 0x02B8, prLower}, // Lm [9] MODIFIER LETTER SMALL H..MODIFIER LETTER SMALL Y - {0x02B9, 0x02BF, prOLetter}, // Lm [7] MODIFIER LETTER PRIME..MODIFIER LETTER LEFT HALF RING - {0x02C0, 0x02C1, prLower}, // Lm [2] MODIFIER LETTER GLOTTAL STOP..MODIFIER LETTER REVERSED GLOTTAL STOP - {0x02C6, 0x02D1, prOLetter}, // Lm [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON - {0x02E0, 0x02E4, prLower}, // Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP - {0x02EC, 0x02EC, prOLetter}, // Lm MODIFIER LETTER VOICING - {0x02EE, 0x02EE, prOLetter}, // Lm MODIFIER LETTER DOUBLE APOSTROPHE - {0x0300, 0x036F, prExtend}, // Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X - {0x0370, 0x0370, prUpper}, // L& GREEK CAPITAL LETTER HETA - {0x0371, 0x0371, prLower}, // L& GREEK SMALL LETTER HETA - {0x0372, 0x0372, prUpper}, // L& GREEK CAPITAL LETTER ARCHAIC SAMPI - {0x0373, 0x0373, prLower}, // L& GREEK SMALL LETTER ARCHAIC SAMPI - {0x0374, 0x0374, prOLetter}, // Lm GREEK NUMERAL SIGN - {0x0376, 0x0376, prUpper}, // L& GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA - {0x0377, 0x0377, prLower}, // L& GREEK SMALL LETTER PAMPHYLIAN DIGAMMA - {0x037A, 0x037A, prLower}, // Lm GREEK YPOGEGRAMMENI - {0x037B, 0x037D, prLower}, // L& [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x037F, 0x037F, prUpper}, // L& GREEK CAPITAL LETTER YOT - {0x0386, 0x0386, prUpper}, // L& GREEK CAPITAL LETTER ALPHA WITH TONOS - {0x0388, 0x038A, prUpper}, // L& [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS - {0x038C, 0x038C, prUpper}, // L& GREEK CAPITAL LETTER OMICRON WITH TONOS - {0x038E, 0x038F, prUpper}, // L& [2] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER OMEGA WITH TONOS - {0x0390, 0x0390, prLower}, // L& GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS - {0x0391, 0x03A1, prUpper}, // L& [17] GREEK CAPITAL LETTER ALPHA..GREEK CAPITAL LETTER RHO - {0x03A3, 0x03AB, prUpper}, // L& [9] GREEK CAPITAL LETTER SIGMA..GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA - {0x03AC, 0x03CE, prLower}, // L& [35] GREEK SMALL LETTER ALPHA WITH TONOS..GREEK SMALL LETTER OMEGA WITH TONOS - {0x03CF, 0x03CF, prUpper}, // L& GREEK CAPITAL KAI SYMBOL - {0x03D0, 0x03D1, prLower}, // L& [2] GREEK BETA SYMBOL..GREEK THETA SYMBOL - {0x03D2, 0x03D4, prUpper}, // L& [3] GREEK UPSILON WITH HOOK SYMBOL..GREEK UPSILON WITH DIAERESIS AND HOOK SYMBOL - {0x03D5, 0x03D7, prLower}, // L& [3] GREEK PHI SYMBOL..GREEK KAI SYMBOL - {0x03D8, 0x03D8, prUpper}, // L& GREEK LETTER ARCHAIC KOPPA - {0x03D9, 0x03D9, prLower}, // L& GREEK SMALL LETTER ARCHAIC KOPPA - {0x03DA, 0x03DA, prUpper}, // L& GREEK LETTER STIGMA - {0x03DB, 0x03DB, prLower}, // L& GREEK SMALL LETTER STIGMA - {0x03DC, 0x03DC, prUpper}, // L& GREEK LETTER DIGAMMA - {0x03DD, 0x03DD, prLower}, // L& GREEK SMALL LETTER DIGAMMA - {0x03DE, 0x03DE, prUpper}, // L& GREEK LETTER KOPPA - {0x03DF, 0x03DF, prLower}, // L& GREEK SMALL LETTER KOPPA - {0x03E0, 0x03E0, prUpper}, // L& GREEK LETTER SAMPI - {0x03E1, 0x03E1, prLower}, // L& GREEK SMALL LETTER SAMPI - {0x03E2, 0x03E2, prUpper}, // L& COPTIC CAPITAL LETTER SHEI - {0x03E3, 0x03E3, prLower}, // L& COPTIC SMALL LETTER SHEI - {0x03E4, 0x03E4, prUpper}, // L& COPTIC CAPITAL LETTER FEI - {0x03E5, 0x03E5, prLower}, // L& COPTIC SMALL LETTER FEI - {0x03E6, 0x03E6, prUpper}, // L& COPTIC CAPITAL LETTER KHEI - {0x03E7, 0x03E7, prLower}, // L& COPTIC SMALL LETTER KHEI - {0x03E8, 0x03E8, prUpper}, // L& COPTIC CAPITAL LETTER HORI - {0x03E9, 0x03E9, prLower}, // L& COPTIC SMALL LETTER HORI - {0x03EA, 0x03EA, prUpper}, // L& COPTIC CAPITAL LETTER GANGIA - {0x03EB, 0x03EB, prLower}, // L& COPTIC SMALL LETTER GANGIA - {0x03EC, 0x03EC, prUpper}, // L& COPTIC CAPITAL LETTER SHIMA - {0x03ED, 0x03ED, prLower}, // L& COPTIC SMALL LETTER SHIMA - {0x03EE, 0x03EE, prUpper}, // L& COPTIC CAPITAL LETTER DEI - {0x03EF, 0x03F3, prLower}, // L& [5] COPTIC SMALL LETTER DEI..GREEK LETTER YOT - {0x03F4, 0x03F4, prUpper}, // L& GREEK CAPITAL THETA SYMBOL - {0x03F5, 0x03F5, prLower}, // L& GREEK LUNATE EPSILON SYMBOL - {0x03F7, 0x03F7, prUpper}, // L& GREEK CAPITAL LETTER SHO - {0x03F8, 0x03F8, prLower}, // L& GREEK SMALL LETTER SHO - {0x03F9, 0x03FA, prUpper}, // L& [2] GREEK CAPITAL LUNATE SIGMA SYMBOL..GREEK CAPITAL LETTER SAN - {0x03FB, 0x03FC, prLower}, // L& [2] GREEK SMALL LETTER SAN..GREEK RHO WITH STROKE SYMBOL - {0x03FD, 0x042F, prUpper}, // L& [51] GREEK CAPITAL REVERSED LUNATE SIGMA SYMBOL..CYRILLIC CAPITAL LETTER YA - {0x0430, 0x045F, prLower}, // L& [48] CYRILLIC SMALL LETTER A..CYRILLIC SMALL LETTER DZHE - {0x0460, 0x0460, prUpper}, // L& CYRILLIC CAPITAL LETTER OMEGA - {0x0461, 0x0461, prLower}, // L& CYRILLIC SMALL LETTER OMEGA - {0x0462, 0x0462, prUpper}, // L& CYRILLIC CAPITAL LETTER YAT - {0x0463, 0x0463, prLower}, // L& CYRILLIC SMALL LETTER YAT - {0x0464, 0x0464, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED E - {0x0465, 0x0465, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED E - {0x0466, 0x0466, prUpper}, // L& CYRILLIC CAPITAL LETTER LITTLE YUS - {0x0467, 0x0467, prLower}, // L& CYRILLIC SMALL LETTER LITTLE YUS - {0x0468, 0x0468, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED LITTLE YUS - {0x0469, 0x0469, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED LITTLE YUS - {0x046A, 0x046A, prUpper}, // L& CYRILLIC CAPITAL LETTER BIG YUS - {0x046B, 0x046B, prLower}, // L& CYRILLIC SMALL LETTER BIG YUS - {0x046C, 0x046C, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED BIG YUS - {0x046D, 0x046D, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED BIG YUS - {0x046E, 0x046E, prUpper}, // L& CYRILLIC CAPITAL LETTER KSI - {0x046F, 0x046F, prLower}, // L& CYRILLIC SMALL LETTER KSI - {0x0470, 0x0470, prUpper}, // L& CYRILLIC CAPITAL LETTER PSI - {0x0471, 0x0471, prLower}, // L& CYRILLIC SMALL LETTER PSI - {0x0472, 0x0472, prUpper}, // L& CYRILLIC CAPITAL LETTER FITA - {0x0473, 0x0473, prLower}, // L& CYRILLIC SMALL LETTER FITA - {0x0474, 0x0474, prUpper}, // L& CYRILLIC CAPITAL LETTER IZHITSA - {0x0475, 0x0475, prLower}, // L& CYRILLIC SMALL LETTER IZHITSA - {0x0476, 0x0476, prUpper}, // L& CYRILLIC CAPITAL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT - {0x0477, 0x0477, prLower}, // L& CYRILLIC SMALL LETTER IZHITSA WITH DOUBLE GRAVE ACCENT - {0x0478, 0x0478, prUpper}, // L& CYRILLIC CAPITAL LETTER UK - {0x0479, 0x0479, prLower}, // L& CYRILLIC SMALL LETTER UK - {0x047A, 0x047A, prUpper}, // L& CYRILLIC CAPITAL LETTER ROUND OMEGA - {0x047B, 0x047B, prLower}, // L& CYRILLIC SMALL LETTER ROUND OMEGA - {0x047C, 0x047C, prUpper}, // L& CYRILLIC CAPITAL LETTER OMEGA WITH TITLO - {0x047D, 0x047D, prLower}, // L& CYRILLIC SMALL LETTER OMEGA WITH TITLO - {0x047E, 0x047E, prUpper}, // L& CYRILLIC CAPITAL LETTER OT - {0x047F, 0x047F, prLower}, // L& CYRILLIC SMALL LETTER OT - {0x0480, 0x0480, prUpper}, // L& CYRILLIC CAPITAL LETTER KOPPA - {0x0481, 0x0481, prLower}, // L& CYRILLIC SMALL LETTER KOPPA - {0x0483, 0x0487, prExtend}, // Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE - {0x0488, 0x0489, prExtend}, // Me [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN - {0x048A, 0x048A, prUpper}, // L& CYRILLIC CAPITAL LETTER SHORT I WITH TAIL - {0x048B, 0x048B, prLower}, // L& CYRILLIC SMALL LETTER SHORT I WITH TAIL - {0x048C, 0x048C, prUpper}, // L& CYRILLIC CAPITAL LETTER SEMISOFT SIGN - {0x048D, 0x048D, prLower}, // L& CYRILLIC SMALL LETTER SEMISOFT SIGN - {0x048E, 0x048E, prUpper}, // L& CYRILLIC CAPITAL LETTER ER WITH TICK - {0x048F, 0x048F, prLower}, // L& CYRILLIC SMALL LETTER ER WITH TICK - {0x0490, 0x0490, prUpper}, // L& CYRILLIC CAPITAL LETTER GHE WITH UPTURN - {0x0491, 0x0491, prLower}, // L& CYRILLIC SMALL LETTER GHE WITH UPTURN - {0x0492, 0x0492, prUpper}, // L& CYRILLIC CAPITAL LETTER GHE WITH STROKE - {0x0493, 0x0493, prLower}, // L& CYRILLIC SMALL LETTER GHE WITH STROKE - {0x0494, 0x0494, prUpper}, // L& CYRILLIC CAPITAL LETTER GHE WITH MIDDLE HOOK - {0x0495, 0x0495, prLower}, // L& CYRILLIC SMALL LETTER GHE WITH MIDDLE HOOK - {0x0496, 0x0496, prUpper}, // L& CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER - {0x0497, 0x0497, prLower}, // L& CYRILLIC SMALL LETTER ZHE WITH DESCENDER - {0x0498, 0x0498, prUpper}, // L& CYRILLIC CAPITAL LETTER ZE WITH DESCENDER - {0x0499, 0x0499, prLower}, // L& CYRILLIC SMALL LETTER ZE WITH DESCENDER - {0x049A, 0x049A, prUpper}, // L& CYRILLIC CAPITAL LETTER KA WITH DESCENDER - {0x049B, 0x049B, prLower}, // L& CYRILLIC SMALL LETTER KA WITH DESCENDER - {0x049C, 0x049C, prUpper}, // L& CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE - {0x049D, 0x049D, prLower}, // L& CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE - {0x049E, 0x049E, prUpper}, // L& CYRILLIC CAPITAL LETTER KA WITH STROKE - {0x049F, 0x049F, prLower}, // L& CYRILLIC SMALL LETTER KA WITH STROKE - {0x04A0, 0x04A0, prUpper}, // L& CYRILLIC CAPITAL LETTER BASHKIR KA - {0x04A1, 0x04A1, prLower}, // L& CYRILLIC SMALL LETTER BASHKIR KA - {0x04A2, 0x04A2, prUpper}, // L& CYRILLIC CAPITAL LETTER EN WITH DESCENDER - {0x04A3, 0x04A3, prLower}, // L& CYRILLIC SMALL LETTER EN WITH DESCENDER - {0x04A4, 0x04A4, prUpper}, // L& CYRILLIC CAPITAL LIGATURE EN GHE - {0x04A5, 0x04A5, prLower}, // L& CYRILLIC SMALL LIGATURE EN GHE - {0x04A6, 0x04A6, prUpper}, // L& CYRILLIC CAPITAL LETTER PE WITH MIDDLE HOOK - {0x04A7, 0x04A7, prLower}, // L& CYRILLIC SMALL LETTER PE WITH MIDDLE HOOK - {0x04A8, 0x04A8, prUpper}, // L& CYRILLIC CAPITAL LETTER ABKHASIAN HA - {0x04A9, 0x04A9, prLower}, // L& CYRILLIC SMALL LETTER ABKHASIAN HA - {0x04AA, 0x04AA, prUpper}, // L& CYRILLIC CAPITAL LETTER ES WITH DESCENDER - {0x04AB, 0x04AB, prLower}, // L& CYRILLIC SMALL LETTER ES WITH DESCENDER - {0x04AC, 0x04AC, prUpper}, // L& CYRILLIC CAPITAL LETTER TE WITH DESCENDER - {0x04AD, 0x04AD, prLower}, // L& CYRILLIC SMALL LETTER TE WITH DESCENDER - {0x04AE, 0x04AE, prUpper}, // L& CYRILLIC CAPITAL LETTER STRAIGHT U - {0x04AF, 0x04AF, prLower}, // L& CYRILLIC SMALL LETTER STRAIGHT U - {0x04B0, 0x04B0, prUpper}, // L& CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE - {0x04B1, 0x04B1, prLower}, // L& CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE - {0x04B2, 0x04B2, prUpper}, // L& CYRILLIC CAPITAL LETTER HA WITH DESCENDER - {0x04B3, 0x04B3, prLower}, // L& CYRILLIC SMALL LETTER HA WITH DESCENDER - {0x04B4, 0x04B4, prUpper}, // L& CYRILLIC CAPITAL LIGATURE TE TSE - {0x04B5, 0x04B5, prLower}, // L& CYRILLIC SMALL LIGATURE TE TSE - {0x04B6, 0x04B6, prUpper}, // L& CYRILLIC CAPITAL LETTER CHE WITH DESCENDER - {0x04B7, 0x04B7, prLower}, // L& CYRILLIC SMALL LETTER CHE WITH DESCENDER - {0x04B8, 0x04B8, prUpper}, // L& CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE - {0x04B9, 0x04B9, prLower}, // L& CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE - {0x04BA, 0x04BA, prUpper}, // L& CYRILLIC CAPITAL LETTER SHHA - {0x04BB, 0x04BB, prLower}, // L& CYRILLIC SMALL LETTER SHHA - {0x04BC, 0x04BC, prUpper}, // L& CYRILLIC CAPITAL LETTER ABKHASIAN CHE - {0x04BD, 0x04BD, prLower}, // L& CYRILLIC SMALL LETTER ABKHASIAN CHE - {0x04BE, 0x04BE, prUpper}, // L& CYRILLIC CAPITAL LETTER ABKHASIAN CHE WITH DESCENDER - {0x04BF, 0x04BF, prLower}, // L& CYRILLIC SMALL LETTER ABKHASIAN CHE WITH DESCENDER - {0x04C0, 0x04C1, prUpper}, // L& [2] CYRILLIC LETTER PALOCHKA..CYRILLIC CAPITAL LETTER ZHE WITH BREVE - {0x04C2, 0x04C2, prLower}, // L& CYRILLIC SMALL LETTER ZHE WITH BREVE - {0x04C3, 0x04C3, prUpper}, // L& CYRILLIC CAPITAL LETTER KA WITH HOOK - {0x04C4, 0x04C4, prLower}, // L& CYRILLIC SMALL LETTER KA WITH HOOK - {0x04C5, 0x04C5, prUpper}, // L& CYRILLIC CAPITAL LETTER EL WITH TAIL - {0x04C6, 0x04C6, prLower}, // L& CYRILLIC SMALL LETTER EL WITH TAIL - {0x04C7, 0x04C7, prUpper}, // L& CYRILLIC CAPITAL LETTER EN WITH HOOK - {0x04C8, 0x04C8, prLower}, // L& CYRILLIC SMALL LETTER EN WITH HOOK - {0x04C9, 0x04C9, prUpper}, // L& CYRILLIC CAPITAL LETTER EN WITH TAIL - {0x04CA, 0x04CA, prLower}, // L& CYRILLIC SMALL LETTER EN WITH TAIL - {0x04CB, 0x04CB, prUpper}, // L& CYRILLIC CAPITAL LETTER KHAKASSIAN CHE - {0x04CC, 0x04CC, prLower}, // L& CYRILLIC SMALL LETTER KHAKASSIAN CHE - {0x04CD, 0x04CD, prUpper}, // L& CYRILLIC CAPITAL LETTER EM WITH TAIL - {0x04CE, 0x04CF, prLower}, // L& [2] CYRILLIC SMALL LETTER EM WITH TAIL..CYRILLIC SMALL LETTER PALOCHKA - {0x04D0, 0x04D0, prUpper}, // L& CYRILLIC CAPITAL LETTER A WITH BREVE - {0x04D1, 0x04D1, prLower}, // L& CYRILLIC SMALL LETTER A WITH BREVE - {0x04D2, 0x04D2, prUpper}, // L& CYRILLIC CAPITAL LETTER A WITH DIAERESIS - {0x04D3, 0x04D3, prLower}, // L& CYRILLIC SMALL LETTER A WITH DIAERESIS - {0x04D4, 0x04D4, prUpper}, // L& CYRILLIC CAPITAL LIGATURE A IE - {0x04D5, 0x04D5, prLower}, // L& CYRILLIC SMALL LIGATURE A IE - {0x04D6, 0x04D6, prUpper}, // L& CYRILLIC CAPITAL LETTER IE WITH BREVE - {0x04D7, 0x04D7, prLower}, // L& CYRILLIC SMALL LETTER IE WITH BREVE - {0x04D8, 0x04D8, prUpper}, // L& CYRILLIC CAPITAL LETTER SCHWA - {0x04D9, 0x04D9, prLower}, // L& CYRILLIC SMALL LETTER SCHWA - {0x04DA, 0x04DA, prUpper}, // L& CYRILLIC CAPITAL LETTER SCHWA WITH DIAERESIS - {0x04DB, 0x04DB, prLower}, // L& CYRILLIC SMALL LETTER SCHWA WITH DIAERESIS - {0x04DC, 0x04DC, prUpper}, // L& CYRILLIC CAPITAL LETTER ZHE WITH DIAERESIS - {0x04DD, 0x04DD, prLower}, // L& CYRILLIC SMALL LETTER ZHE WITH DIAERESIS - {0x04DE, 0x04DE, prUpper}, // L& CYRILLIC CAPITAL LETTER ZE WITH DIAERESIS - {0x04DF, 0x04DF, prLower}, // L& CYRILLIC SMALL LETTER ZE WITH DIAERESIS - {0x04E0, 0x04E0, prUpper}, // L& CYRILLIC CAPITAL LETTER ABKHASIAN DZE - {0x04E1, 0x04E1, prLower}, // L& CYRILLIC SMALL LETTER ABKHASIAN DZE - {0x04E2, 0x04E2, prUpper}, // L& CYRILLIC CAPITAL LETTER I WITH MACRON - {0x04E3, 0x04E3, prLower}, // L& CYRILLIC SMALL LETTER I WITH MACRON - {0x04E4, 0x04E4, prUpper}, // L& CYRILLIC CAPITAL LETTER I WITH DIAERESIS - {0x04E5, 0x04E5, prLower}, // L& CYRILLIC SMALL LETTER I WITH DIAERESIS - {0x04E6, 0x04E6, prUpper}, // L& CYRILLIC CAPITAL LETTER O WITH DIAERESIS - {0x04E7, 0x04E7, prLower}, // L& CYRILLIC SMALL LETTER O WITH DIAERESIS - {0x04E8, 0x04E8, prUpper}, // L& CYRILLIC CAPITAL LETTER BARRED O - {0x04E9, 0x04E9, prLower}, // L& CYRILLIC SMALL LETTER BARRED O - {0x04EA, 0x04EA, prUpper}, // L& CYRILLIC CAPITAL LETTER BARRED O WITH DIAERESIS - {0x04EB, 0x04EB, prLower}, // L& CYRILLIC SMALL LETTER BARRED O WITH DIAERESIS - {0x04EC, 0x04EC, prUpper}, // L& CYRILLIC CAPITAL LETTER E WITH DIAERESIS - {0x04ED, 0x04ED, prLower}, // L& CYRILLIC SMALL LETTER E WITH DIAERESIS - {0x04EE, 0x04EE, prUpper}, // L& CYRILLIC CAPITAL LETTER U WITH MACRON - {0x04EF, 0x04EF, prLower}, // L& CYRILLIC SMALL LETTER U WITH MACRON - {0x04F0, 0x04F0, prUpper}, // L& CYRILLIC CAPITAL LETTER U WITH DIAERESIS - {0x04F1, 0x04F1, prLower}, // L& CYRILLIC SMALL LETTER U WITH DIAERESIS - {0x04F2, 0x04F2, prUpper}, // L& CYRILLIC CAPITAL LETTER U WITH DOUBLE ACUTE - {0x04F3, 0x04F3, prLower}, // L& CYRILLIC SMALL LETTER U WITH DOUBLE ACUTE - {0x04F4, 0x04F4, prUpper}, // L& CYRILLIC CAPITAL LETTER CHE WITH DIAERESIS - {0x04F5, 0x04F5, prLower}, // L& CYRILLIC SMALL LETTER CHE WITH DIAERESIS - {0x04F6, 0x04F6, prUpper}, // L& CYRILLIC CAPITAL LETTER GHE WITH DESCENDER - {0x04F7, 0x04F7, prLower}, // L& CYRILLIC SMALL LETTER GHE WITH DESCENDER - {0x04F8, 0x04F8, prUpper}, // L& CYRILLIC CAPITAL LETTER YERU WITH DIAERESIS - {0x04F9, 0x04F9, prLower}, // L& CYRILLIC SMALL LETTER YERU WITH DIAERESIS - {0x04FA, 0x04FA, prUpper}, // L& CYRILLIC CAPITAL LETTER GHE WITH STROKE AND HOOK - {0x04FB, 0x04FB, prLower}, // L& CYRILLIC SMALL LETTER GHE WITH STROKE AND HOOK - {0x04FC, 0x04FC, prUpper}, // L& CYRILLIC CAPITAL LETTER HA WITH HOOK - {0x04FD, 0x04FD, prLower}, // L& CYRILLIC SMALL LETTER HA WITH HOOK - {0x04FE, 0x04FE, prUpper}, // L& CYRILLIC CAPITAL LETTER HA WITH STROKE - {0x04FF, 0x04FF, prLower}, // L& CYRILLIC SMALL LETTER HA WITH STROKE - {0x0500, 0x0500, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI DE - {0x0501, 0x0501, prLower}, // L& CYRILLIC SMALL LETTER KOMI DE - {0x0502, 0x0502, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI DJE - {0x0503, 0x0503, prLower}, // L& CYRILLIC SMALL LETTER KOMI DJE - {0x0504, 0x0504, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI ZJE - {0x0505, 0x0505, prLower}, // L& CYRILLIC SMALL LETTER KOMI ZJE - {0x0506, 0x0506, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI DZJE - {0x0507, 0x0507, prLower}, // L& CYRILLIC SMALL LETTER KOMI DZJE - {0x0508, 0x0508, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI LJE - {0x0509, 0x0509, prLower}, // L& CYRILLIC SMALL LETTER KOMI LJE - {0x050A, 0x050A, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI NJE - {0x050B, 0x050B, prLower}, // L& CYRILLIC SMALL LETTER KOMI NJE - {0x050C, 0x050C, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI SJE - {0x050D, 0x050D, prLower}, // L& CYRILLIC SMALL LETTER KOMI SJE - {0x050E, 0x050E, prUpper}, // L& CYRILLIC CAPITAL LETTER KOMI TJE - {0x050F, 0x050F, prLower}, // L& CYRILLIC SMALL LETTER KOMI TJE - {0x0510, 0x0510, prUpper}, // L& CYRILLIC CAPITAL LETTER REVERSED ZE - {0x0511, 0x0511, prLower}, // L& CYRILLIC SMALL LETTER REVERSED ZE - {0x0512, 0x0512, prUpper}, // L& CYRILLIC CAPITAL LETTER EL WITH HOOK - {0x0513, 0x0513, prLower}, // L& CYRILLIC SMALL LETTER EL WITH HOOK - {0x0514, 0x0514, prUpper}, // L& CYRILLIC CAPITAL LETTER LHA - {0x0515, 0x0515, prLower}, // L& CYRILLIC SMALL LETTER LHA - {0x0516, 0x0516, prUpper}, // L& CYRILLIC CAPITAL LETTER RHA - {0x0517, 0x0517, prLower}, // L& CYRILLIC SMALL LETTER RHA - {0x0518, 0x0518, prUpper}, // L& CYRILLIC CAPITAL LETTER YAE - {0x0519, 0x0519, prLower}, // L& CYRILLIC SMALL LETTER YAE - {0x051A, 0x051A, prUpper}, // L& CYRILLIC CAPITAL LETTER QA - {0x051B, 0x051B, prLower}, // L& CYRILLIC SMALL LETTER QA - {0x051C, 0x051C, prUpper}, // L& CYRILLIC CAPITAL LETTER WE - {0x051D, 0x051D, prLower}, // L& CYRILLIC SMALL LETTER WE - {0x051E, 0x051E, prUpper}, // L& CYRILLIC CAPITAL LETTER ALEUT KA - {0x051F, 0x051F, prLower}, // L& CYRILLIC SMALL LETTER ALEUT KA - {0x0520, 0x0520, prUpper}, // L& CYRILLIC CAPITAL LETTER EL WITH MIDDLE HOOK - {0x0521, 0x0521, prLower}, // L& CYRILLIC SMALL LETTER EL WITH MIDDLE HOOK - {0x0522, 0x0522, prUpper}, // L& CYRILLIC CAPITAL LETTER EN WITH MIDDLE HOOK - {0x0523, 0x0523, prLower}, // L& CYRILLIC SMALL LETTER EN WITH MIDDLE HOOK - {0x0524, 0x0524, prUpper}, // L& CYRILLIC CAPITAL LETTER PE WITH DESCENDER - {0x0525, 0x0525, prLower}, // L& CYRILLIC SMALL LETTER PE WITH DESCENDER - {0x0526, 0x0526, prUpper}, // L& CYRILLIC CAPITAL LETTER SHHA WITH DESCENDER - {0x0527, 0x0527, prLower}, // L& CYRILLIC SMALL LETTER SHHA WITH DESCENDER - {0x0528, 0x0528, prUpper}, // L& CYRILLIC CAPITAL LETTER EN WITH LEFT HOOK - {0x0529, 0x0529, prLower}, // L& CYRILLIC SMALL LETTER EN WITH LEFT HOOK - {0x052A, 0x052A, prUpper}, // L& CYRILLIC CAPITAL LETTER DZZHE - {0x052B, 0x052B, prLower}, // L& CYRILLIC SMALL LETTER DZZHE - {0x052C, 0x052C, prUpper}, // L& CYRILLIC CAPITAL LETTER DCHE - {0x052D, 0x052D, prLower}, // L& CYRILLIC SMALL LETTER DCHE - {0x052E, 0x052E, prUpper}, // L& CYRILLIC CAPITAL LETTER EL WITH DESCENDER - {0x052F, 0x052F, prLower}, // L& CYRILLIC SMALL LETTER EL WITH DESCENDER - {0x0531, 0x0556, prUpper}, // L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH - {0x0559, 0x0559, prOLetter}, // Lm ARMENIAN MODIFIER LETTER LEFT HALF RING - {0x055D, 0x055D, prSContinue}, // Po ARMENIAN COMMA - {0x0560, 0x0588, prLower}, // L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE - {0x0589, 0x0589, prSTerm}, // Po ARMENIAN FULL STOP - {0x0591, 0x05BD, prExtend}, // Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG - {0x05BF, 0x05BF, prExtend}, // Mn HEBREW POINT RAFE - {0x05C1, 0x05C2, prExtend}, // Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT - {0x05C4, 0x05C5, prExtend}, // Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT - {0x05C7, 0x05C7, prExtend}, // Mn HEBREW POINT QAMATS QATAN - {0x05D0, 0x05EA, prOLetter}, // Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV - {0x05EF, 0x05F2, prOLetter}, // Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD - {0x05F3, 0x05F3, prOLetter}, // Po HEBREW PUNCTUATION GERESH - {0x0600, 0x0605, prFormat}, // Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE - {0x060C, 0x060D, prSContinue}, // Po [2] ARABIC COMMA..ARABIC DATE SEPARATOR - {0x0610, 0x061A, prExtend}, // Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA - {0x061C, 0x061C, prFormat}, // Cf ARABIC LETTER MARK - {0x061D, 0x061F, prSTerm}, // Po [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK - {0x0620, 0x063F, prOLetter}, // Lo [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE - {0x0640, 0x0640, prOLetter}, // Lm ARABIC TATWEEL - {0x0641, 0x064A, prOLetter}, // Lo [10] ARABIC LETTER FEH..ARABIC LETTER YEH - {0x064B, 0x065F, prExtend}, // Mn [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW - {0x0660, 0x0669, prNumeric}, // Nd [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE - {0x066B, 0x066C, prNumeric}, // Po [2] ARABIC DECIMAL SEPARATOR..ARABIC THOUSANDS SEPARATOR - {0x066E, 0x066F, prOLetter}, // Lo [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF - {0x0670, 0x0670, prExtend}, // Mn ARABIC LETTER SUPERSCRIPT ALEF - {0x0671, 0x06D3, prOLetter}, // Lo [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE - {0x06D4, 0x06D4, prSTerm}, // Po ARABIC FULL STOP - {0x06D5, 0x06D5, prOLetter}, // Lo ARABIC LETTER AE - {0x06D6, 0x06DC, prExtend}, // Mn [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN - {0x06DD, 0x06DD, prFormat}, // Cf ARABIC END OF AYAH - {0x06DF, 0x06E4, prExtend}, // Mn [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA - {0x06E5, 0x06E6, prOLetter}, // Lm [2] ARABIC SMALL WAW..ARABIC SMALL YEH - {0x06E7, 0x06E8, prExtend}, // Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON - {0x06EA, 0x06ED, prExtend}, // Mn [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM - {0x06EE, 0x06EF, prOLetter}, // Lo [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V - {0x06F0, 0x06F9, prNumeric}, // Nd [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE - {0x06FA, 0x06FC, prOLetter}, // Lo [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW - {0x06FF, 0x06FF, prOLetter}, // Lo ARABIC LETTER HEH WITH INVERTED V - {0x0700, 0x0702, prSTerm}, // Po [3] SYRIAC END OF PARAGRAPH..SYRIAC SUBLINEAR FULL STOP - {0x070F, 0x070F, prFormat}, // Cf SYRIAC ABBREVIATION MARK - {0x0710, 0x0710, prOLetter}, // Lo SYRIAC LETTER ALAPH - {0x0711, 0x0711, prExtend}, // Mn SYRIAC LETTER SUPERSCRIPT ALAPH - {0x0712, 0x072F, prOLetter}, // Lo [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH - {0x0730, 0x074A, prExtend}, // Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH - {0x074D, 0x07A5, prOLetter}, // Lo [89] SYRIAC LETTER SOGDIAN ZHAIN..THAANA LETTER WAAVU - {0x07A6, 0x07B0, prExtend}, // Mn [11] THAANA ABAFILI..THAANA SUKUN - {0x07B1, 0x07B1, prOLetter}, // Lo THAANA LETTER NAA - {0x07C0, 0x07C9, prNumeric}, // Nd [10] NKO DIGIT ZERO..NKO DIGIT NINE - {0x07CA, 0x07EA, prOLetter}, // Lo [33] NKO LETTER A..NKO LETTER JONA RA - {0x07EB, 0x07F3, prExtend}, // Mn [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE - {0x07F4, 0x07F5, prOLetter}, // Lm [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE - {0x07F8, 0x07F8, prSContinue}, // Po NKO COMMA - {0x07F9, 0x07F9, prSTerm}, // Po NKO EXCLAMATION MARK - {0x07FA, 0x07FA, prOLetter}, // Lm NKO LAJANYALAN - {0x07FD, 0x07FD, prExtend}, // Mn NKO DANTAYALAN - {0x0800, 0x0815, prOLetter}, // Lo [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF - {0x0816, 0x0819, prExtend}, // Mn [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH - {0x081A, 0x081A, prOLetter}, // Lm SAMARITAN MODIFIER LETTER EPENTHETIC YUT - {0x081B, 0x0823, prExtend}, // Mn [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A - {0x0824, 0x0824, prOLetter}, // Lm SAMARITAN MODIFIER LETTER SHORT A - {0x0825, 0x0827, prExtend}, // Mn [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U - {0x0828, 0x0828, prOLetter}, // Lm SAMARITAN MODIFIER LETTER I - {0x0829, 0x082D, prExtend}, // Mn [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA - {0x0837, 0x0837, prSTerm}, // Po SAMARITAN PUNCTUATION MELODIC QITSA - {0x0839, 0x0839, prSTerm}, // Po SAMARITAN PUNCTUATION QITSA - {0x083D, 0x083E, prSTerm}, // Po [2] SAMARITAN PUNCTUATION SOF MASHFAAT..SAMARITAN PUNCTUATION ANNAAU - {0x0840, 0x0858, prOLetter}, // Lo [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN - {0x0859, 0x085B, prExtend}, // Mn [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK - {0x0860, 0x086A, prOLetter}, // Lo [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA - {0x0870, 0x0887, prOLetter}, // Lo [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT - {0x0889, 0x088E, prOLetter}, // Lo [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL - {0x0890, 0x0891, prFormat}, // Cf [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE - {0x0898, 0x089F, prExtend}, // Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA - {0x08A0, 0x08C8, prOLetter}, // Lo [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF - {0x08C9, 0x08C9, prOLetter}, // Lm ARABIC SMALL FARSI YEH - {0x08CA, 0x08E1, prExtend}, // Mn [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA - {0x08E2, 0x08E2, prFormat}, // Cf ARABIC DISPUTED END OF AYAH - {0x08E3, 0x0902, prExtend}, // Mn [32] ARABIC TURNED DAMMA BELOW..DEVANAGARI SIGN ANUSVARA - {0x0903, 0x0903, prExtend}, // Mc DEVANAGARI SIGN VISARGA - {0x0904, 0x0939, prOLetter}, // Lo [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA - {0x093A, 0x093A, prExtend}, // Mn DEVANAGARI VOWEL SIGN OE - {0x093B, 0x093B, prExtend}, // Mc DEVANAGARI VOWEL SIGN OOE - {0x093C, 0x093C, prExtend}, // Mn DEVANAGARI SIGN NUKTA - {0x093D, 0x093D, prOLetter}, // Lo DEVANAGARI SIGN AVAGRAHA - {0x093E, 0x0940, prExtend}, // Mc [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II - {0x0941, 0x0948, prExtend}, // Mn [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI - {0x0949, 0x094C, prExtend}, // Mc [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU - {0x094D, 0x094D, prExtend}, // Mn DEVANAGARI SIGN VIRAMA - {0x094E, 0x094F, prExtend}, // Mc [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW - {0x0950, 0x0950, prOLetter}, // Lo DEVANAGARI OM - {0x0951, 0x0957, prExtend}, // Mn [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE - {0x0958, 0x0961, prOLetter}, // Lo [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL - {0x0962, 0x0963, prExtend}, // Mn [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL - {0x0964, 0x0965, prSTerm}, // Po [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA - {0x0966, 0x096F, prNumeric}, // Nd [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE - {0x0971, 0x0971, prOLetter}, // Lm DEVANAGARI SIGN HIGH SPACING DOT - {0x0972, 0x0980, prOLetter}, // Lo [15] DEVANAGARI LETTER CANDRA A..BENGALI ANJI - {0x0981, 0x0981, prExtend}, // Mn BENGALI SIGN CANDRABINDU - {0x0982, 0x0983, prExtend}, // Mc [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA - {0x0985, 0x098C, prOLetter}, // Lo [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L - {0x098F, 0x0990, prOLetter}, // Lo [2] BENGALI LETTER E..BENGALI LETTER AI - {0x0993, 0x09A8, prOLetter}, // Lo [22] BENGALI LETTER O..BENGALI LETTER NA - {0x09AA, 0x09B0, prOLetter}, // Lo [7] BENGALI LETTER PA..BENGALI LETTER RA - {0x09B2, 0x09B2, prOLetter}, // Lo BENGALI LETTER LA - {0x09B6, 0x09B9, prOLetter}, // Lo [4] BENGALI LETTER SHA..BENGALI LETTER HA - {0x09BC, 0x09BC, prExtend}, // Mn BENGALI SIGN NUKTA - {0x09BD, 0x09BD, prOLetter}, // Lo BENGALI SIGN AVAGRAHA - {0x09BE, 0x09C0, prExtend}, // Mc [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II - {0x09C1, 0x09C4, prExtend}, // Mn [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR - {0x09C7, 0x09C8, prExtend}, // Mc [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI - {0x09CB, 0x09CC, prExtend}, // Mc [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU - {0x09CD, 0x09CD, prExtend}, // Mn BENGALI SIGN VIRAMA - {0x09CE, 0x09CE, prOLetter}, // Lo BENGALI LETTER KHANDA TA - {0x09D7, 0x09D7, prExtend}, // Mc BENGALI AU LENGTH MARK - {0x09DC, 0x09DD, prOLetter}, // Lo [2] BENGALI LETTER RRA..BENGALI LETTER RHA - {0x09DF, 0x09E1, prOLetter}, // Lo [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL - {0x09E2, 0x09E3, prExtend}, // Mn [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL - {0x09E6, 0x09EF, prNumeric}, // Nd [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE - {0x09F0, 0x09F1, prOLetter}, // Lo [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL - {0x09FC, 0x09FC, prOLetter}, // Lo BENGALI LETTER VEDIC ANUSVARA - {0x09FE, 0x09FE, prExtend}, // Mn BENGALI SANDHI MARK - {0x0A01, 0x0A02, prExtend}, // Mn [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI - {0x0A03, 0x0A03, prExtend}, // Mc GURMUKHI SIGN VISARGA - {0x0A05, 0x0A0A, prOLetter}, // Lo [6] GURMUKHI LETTER A..GURMUKHI LETTER UU - {0x0A0F, 0x0A10, prOLetter}, // Lo [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI - {0x0A13, 0x0A28, prOLetter}, // Lo [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA - {0x0A2A, 0x0A30, prOLetter}, // Lo [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA - {0x0A32, 0x0A33, prOLetter}, // Lo [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA - {0x0A35, 0x0A36, prOLetter}, // Lo [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA - {0x0A38, 0x0A39, prOLetter}, // Lo [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA - {0x0A3C, 0x0A3C, prExtend}, // Mn GURMUKHI SIGN NUKTA - {0x0A3E, 0x0A40, prExtend}, // Mc [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II - {0x0A41, 0x0A42, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU - {0x0A47, 0x0A48, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI - {0x0A4B, 0x0A4D, prExtend}, // Mn [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA - {0x0A51, 0x0A51, prExtend}, // Mn GURMUKHI SIGN UDAAT - {0x0A59, 0x0A5C, prOLetter}, // Lo [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA - {0x0A5E, 0x0A5E, prOLetter}, // Lo GURMUKHI LETTER FA - {0x0A66, 0x0A6F, prNumeric}, // Nd [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE - {0x0A70, 0x0A71, prExtend}, // Mn [2] GURMUKHI TIPPI..GURMUKHI ADDAK - {0x0A72, 0x0A74, prOLetter}, // Lo [3] GURMUKHI IRI..GURMUKHI EK ONKAR - {0x0A75, 0x0A75, prExtend}, // Mn GURMUKHI SIGN YAKASH - {0x0A81, 0x0A82, prExtend}, // Mn [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA - {0x0A83, 0x0A83, prExtend}, // Mc GUJARATI SIGN VISARGA - {0x0A85, 0x0A8D, prOLetter}, // Lo [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E - {0x0A8F, 0x0A91, prOLetter}, // Lo [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O - {0x0A93, 0x0AA8, prOLetter}, // Lo [22] GUJARATI LETTER O..GUJARATI LETTER NA - {0x0AAA, 0x0AB0, prOLetter}, // Lo [7] GUJARATI LETTER PA..GUJARATI LETTER RA - {0x0AB2, 0x0AB3, prOLetter}, // Lo [2] GUJARATI LETTER LA..GUJARATI LETTER LLA - {0x0AB5, 0x0AB9, prOLetter}, // Lo [5] GUJARATI LETTER VA..GUJARATI LETTER HA - {0x0ABC, 0x0ABC, prExtend}, // Mn GUJARATI SIGN NUKTA - {0x0ABD, 0x0ABD, prOLetter}, // Lo GUJARATI SIGN AVAGRAHA - {0x0ABE, 0x0AC0, prExtend}, // Mc [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II - {0x0AC1, 0x0AC5, prExtend}, // Mn [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E - {0x0AC7, 0x0AC8, prExtend}, // Mn [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI - {0x0AC9, 0x0AC9, prExtend}, // Mc GUJARATI VOWEL SIGN CANDRA O - {0x0ACB, 0x0ACC, prExtend}, // Mc [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU - {0x0ACD, 0x0ACD, prExtend}, // Mn GUJARATI SIGN VIRAMA - {0x0AD0, 0x0AD0, prOLetter}, // Lo GUJARATI OM - {0x0AE0, 0x0AE1, prOLetter}, // Lo [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL - {0x0AE2, 0x0AE3, prExtend}, // Mn [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL - {0x0AE6, 0x0AEF, prNumeric}, // Nd [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE - {0x0AF9, 0x0AF9, prOLetter}, // Lo GUJARATI LETTER ZHA - {0x0AFA, 0x0AFF, prExtend}, // Mn [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE - {0x0B01, 0x0B01, prExtend}, // Mn ORIYA SIGN CANDRABINDU - {0x0B02, 0x0B03, prExtend}, // Mc [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA - {0x0B05, 0x0B0C, prOLetter}, // Lo [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L - {0x0B0F, 0x0B10, prOLetter}, // Lo [2] ORIYA LETTER E..ORIYA LETTER AI - {0x0B13, 0x0B28, prOLetter}, // Lo [22] ORIYA LETTER O..ORIYA LETTER NA - {0x0B2A, 0x0B30, prOLetter}, // Lo [7] ORIYA LETTER PA..ORIYA LETTER RA - {0x0B32, 0x0B33, prOLetter}, // Lo [2] ORIYA LETTER LA..ORIYA LETTER LLA - {0x0B35, 0x0B39, prOLetter}, // Lo [5] ORIYA LETTER VA..ORIYA LETTER HA - {0x0B3C, 0x0B3C, prExtend}, // Mn ORIYA SIGN NUKTA - {0x0B3D, 0x0B3D, prOLetter}, // Lo ORIYA SIGN AVAGRAHA - {0x0B3E, 0x0B3E, prExtend}, // Mc ORIYA VOWEL SIGN AA - {0x0B3F, 0x0B3F, prExtend}, // Mn ORIYA VOWEL SIGN I - {0x0B40, 0x0B40, prExtend}, // Mc ORIYA VOWEL SIGN II - {0x0B41, 0x0B44, prExtend}, // Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR - {0x0B47, 0x0B48, prExtend}, // Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI - {0x0B4B, 0x0B4C, prExtend}, // Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU - {0x0B4D, 0x0B4D, prExtend}, // Mn ORIYA SIGN VIRAMA - {0x0B55, 0x0B56, prExtend}, // Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK - {0x0B57, 0x0B57, prExtend}, // Mc ORIYA AU LENGTH MARK - {0x0B5C, 0x0B5D, prOLetter}, // Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA - {0x0B5F, 0x0B61, prOLetter}, // Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL - {0x0B62, 0x0B63, prExtend}, // Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL - {0x0B66, 0x0B6F, prNumeric}, // Nd [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE - {0x0B71, 0x0B71, prOLetter}, // Lo ORIYA LETTER WA - {0x0B82, 0x0B82, prExtend}, // Mn TAMIL SIGN ANUSVARA - {0x0B83, 0x0B83, prOLetter}, // Lo TAMIL SIGN VISARGA - {0x0B85, 0x0B8A, prOLetter}, // Lo [6] TAMIL LETTER A..TAMIL LETTER UU - {0x0B8E, 0x0B90, prOLetter}, // Lo [3] TAMIL LETTER E..TAMIL LETTER AI - {0x0B92, 0x0B95, prOLetter}, // Lo [4] TAMIL LETTER O..TAMIL LETTER KA - {0x0B99, 0x0B9A, prOLetter}, // Lo [2] TAMIL LETTER NGA..TAMIL LETTER CA - {0x0B9C, 0x0B9C, prOLetter}, // Lo TAMIL LETTER JA - {0x0B9E, 0x0B9F, prOLetter}, // Lo [2] TAMIL LETTER NYA..TAMIL LETTER TTA - {0x0BA3, 0x0BA4, prOLetter}, // Lo [2] TAMIL LETTER NNA..TAMIL LETTER TA - {0x0BA8, 0x0BAA, prOLetter}, // Lo [3] TAMIL LETTER NA..TAMIL LETTER PA - {0x0BAE, 0x0BB9, prOLetter}, // Lo [12] TAMIL LETTER MA..TAMIL LETTER HA - {0x0BBE, 0x0BBF, prExtend}, // Mc [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I - {0x0BC0, 0x0BC0, prExtend}, // Mn TAMIL VOWEL SIGN II - {0x0BC1, 0x0BC2, prExtend}, // Mc [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU - {0x0BC6, 0x0BC8, prExtend}, // Mc [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI - {0x0BCA, 0x0BCC, prExtend}, // Mc [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU - {0x0BCD, 0x0BCD, prExtend}, // Mn TAMIL SIGN VIRAMA - {0x0BD0, 0x0BD0, prOLetter}, // Lo TAMIL OM - {0x0BD7, 0x0BD7, prExtend}, // Mc TAMIL AU LENGTH MARK - {0x0BE6, 0x0BEF, prNumeric}, // Nd [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE - {0x0C00, 0x0C00, prExtend}, // Mn TELUGU SIGN COMBINING CANDRABINDU ABOVE - {0x0C01, 0x0C03, prExtend}, // Mc [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA - {0x0C04, 0x0C04, prExtend}, // Mn TELUGU SIGN COMBINING ANUSVARA ABOVE - {0x0C05, 0x0C0C, prOLetter}, // Lo [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L - {0x0C0E, 0x0C10, prOLetter}, // Lo [3] TELUGU LETTER E..TELUGU LETTER AI - {0x0C12, 0x0C28, prOLetter}, // Lo [23] TELUGU LETTER O..TELUGU LETTER NA - {0x0C2A, 0x0C39, prOLetter}, // Lo [16] TELUGU LETTER PA..TELUGU LETTER HA - {0x0C3C, 0x0C3C, prExtend}, // Mn TELUGU SIGN NUKTA - {0x0C3D, 0x0C3D, prOLetter}, // Lo TELUGU SIGN AVAGRAHA - {0x0C3E, 0x0C40, prExtend}, // Mn [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II - {0x0C41, 0x0C44, prExtend}, // Mc [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR - {0x0C46, 0x0C48, prExtend}, // Mn [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI - {0x0C4A, 0x0C4D, prExtend}, // Mn [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA - {0x0C55, 0x0C56, prExtend}, // Mn [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK - {0x0C58, 0x0C5A, prOLetter}, // Lo [3] TELUGU LETTER TSA..TELUGU LETTER RRRA - {0x0C5D, 0x0C5D, prOLetter}, // Lo TELUGU LETTER NAKAARA POLLU - {0x0C60, 0x0C61, prOLetter}, // Lo [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL - {0x0C62, 0x0C63, prExtend}, // Mn [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL - {0x0C66, 0x0C6F, prNumeric}, // Nd [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE - {0x0C80, 0x0C80, prOLetter}, // Lo KANNADA SIGN SPACING CANDRABINDU - {0x0C81, 0x0C81, prExtend}, // Mn KANNADA SIGN CANDRABINDU - {0x0C82, 0x0C83, prExtend}, // Mc [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA - {0x0C85, 0x0C8C, prOLetter}, // Lo [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L - {0x0C8E, 0x0C90, prOLetter}, // Lo [3] KANNADA LETTER E..KANNADA LETTER AI - {0x0C92, 0x0CA8, prOLetter}, // Lo [23] KANNADA LETTER O..KANNADA LETTER NA - {0x0CAA, 0x0CB3, prOLetter}, // Lo [10] KANNADA LETTER PA..KANNADA LETTER LLA - {0x0CB5, 0x0CB9, prOLetter}, // Lo [5] KANNADA LETTER VA..KANNADA LETTER HA - {0x0CBC, 0x0CBC, prExtend}, // Mn KANNADA SIGN NUKTA - {0x0CBD, 0x0CBD, prOLetter}, // Lo KANNADA SIGN AVAGRAHA - {0x0CBE, 0x0CBE, prExtend}, // Mc KANNADA VOWEL SIGN AA - {0x0CBF, 0x0CBF, prExtend}, // Mn KANNADA VOWEL SIGN I - {0x0CC0, 0x0CC4, prExtend}, // Mc [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR - {0x0CC6, 0x0CC6, prExtend}, // Mn KANNADA VOWEL SIGN E - {0x0CC7, 0x0CC8, prExtend}, // Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI - {0x0CCA, 0x0CCB, prExtend}, // Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO - {0x0CCC, 0x0CCD, prExtend}, // Mn [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA - {0x0CD5, 0x0CD6, prExtend}, // Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK - {0x0CDD, 0x0CDE, prOLetter}, // Lo [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA - {0x0CE0, 0x0CE1, prOLetter}, // Lo [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL - {0x0CE2, 0x0CE3, prExtend}, // Mn [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL - {0x0CE6, 0x0CEF, prNumeric}, // Nd [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE - {0x0CF1, 0x0CF2, prOLetter}, // Lo [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA - {0x0CF3, 0x0CF3, prExtend}, // Mc KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT - {0x0D00, 0x0D01, prExtend}, // Mn [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU - {0x0D02, 0x0D03, prExtend}, // Mc [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA - {0x0D04, 0x0D0C, prOLetter}, // Lo [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L - {0x0D0E, 0x0D10, prOLetter}, // Lo [3] MALAYALAM LETTER E..MALAYALAM LETTER AI - {0x0D12, 0x0D3A, prOLetter}, // Lo [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA - {0x0D3B, 0x0D3C, prExtend}, // Mn [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA - {0x0D3D, 0x0D3D, prOLetter}, // Lo MALAYALAM SIGN AVAGRAHA - {0x0D3E, 0x0D40, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II - {0x0D41, 0x0D44, prExtend}, // Mn [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR - {0x0D46, 0x0D48, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI - {0x0D4A, 0x0D4C, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU - {0x0D4D, 0x0D4D, prExtend}, // Mn MALAYALAM SIGN VIRAMA - {0x0D4E, 0x0D4E, prOLetter}, // Lo MALAYALAM LETTER DOT REPH - {0x0D54, 0x0D56, prOLetter}, // Lo [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL - {0x0D57, 0x0D57, prExtend}, // Mc MALAYALAM AU LENGTH MARK - {0x0D5F, 0x0D61, prOLetter}, // Lo [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL - {0x0D62, 0x0D63, prExtend}, // Mn [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL - {0x0D66, 0x0D6F, prNumeric}, // Nd [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE - {0x0D7A, 0x0D7F, prOLetter}, // Lo [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K - {0x0D81, 0x0D81, prExtend}, // Mn SINHALA SIGN CANDRABINDU - {0x0D82, 0x0D83, prExtend}, // Mc [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA - {0x0D85, 0x0D96, prOLetter}, // Lo [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA - {0x0D9A, 0x0DB1, prOLetter}, // Lo [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA - {0x0DB3, 0x0DBB, prOLetter}, // Lo [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA - {0x0DBD, 0x0DBD, prOLetter}, // Lo SINHALA LETTER DANTAJA LAYANNA - {0x0DC0, 0x0DC6, prOLetter}, // Lo [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA - {0x0DCA, 0x0DCA, prExtend}, // Mn SINHALA SIGN AL-LAKUNA - {0x0DCF, 0x0DD1, prExtend}, // Mc [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA - {0x0DD2, 0x0DD4, prExtend}, // Mn [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA - {0x0DD6, 0x0DD6, prExtend}, // Mn SINHALA VOWEL SIGN DIGA PAA-PILLA - {0x0DD8, 0x0DDF, prExtend}, // Mc [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA - {0x0DE6, 0x0DEF, prNumeric}, // Nd [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE - {0x0DF2, 0x0DF3, prExtend}, // Mc [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA - {0x0E01, 0x0E30, prOLetter}, // Lo [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A - {0x0E31, 0x0E31, prExtend}, // Mn THAI CHARACTER MAI HAN-AKAT - {0x0E32, 0x0E33, prOLetter}, // Lo [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM - {0x0E34, 0x0E3A, prExtend}, // Mn [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU - {0x0E40, 0x0E45, prOLetter}, // Lo [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO - {0x0E46, 0x0E46, prOLetter}, // Lm THAI CHARACTER MAIYAMOK - {0x0E47, 0x0E4E, prExtend}, // Mn [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN - {0x0E50, 0x0E59, prNumeric}, // Nd [10] THAI DIGIT ZERO..THAI DIGIT NINE - {0x0E81, 0x0E82, prOLetter}, // Lo [2] LAO LETTER KO..LAO LETTER KHO SUNG - {0x0E84, 0x0E84, prOLetter}, // Lo LAO LETTER KHO TAM - {0x0E86, 0x0E8A, prOLetter}, // Lo [5] LAO LETTER PALI GHA..LAO LETTER SO TAM - {0x0E8C, 0x0EA3, prOLetter}, // Lo [24] LAO LETTER PALI JHA..LAO LETTER LO LING - {0x0EA5, 0x0EA5, prOLetter}, // Lo LAO LETTER LO LOOT - {0x0EA7, 0x0EB0, prOLetter}, // Lo [10] LAO LETTER WO..LAO VOWEL SIGN A - {0x0EB1, 0x0EB1, prExtend}, // Mn LAO VOWEL SIGN MAI KAN - {0x0EB2, 0x0EB3, prOLetter}, // Lo [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM - {0x0EB4, 0x0EBC, prExtend}, // Mn [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO - {0x0EBD, 0x0EBD, prOLetter}, // Lo LAO SEMIVOWEL SIGN NYO - {0x0EC0, 0x0EC4, prOLetter}, // Lo [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI - {0x0EC6, 0x0EC6, prOLetter}, // Lm LAO KO LA - {0x0EC8, 0x0ECE, prExtend}, // Mn [7] LAO TONE MAI EK..LAO YAMAKKAN - {0x0ED0, 0x0ED9, prNumeric}, // Nd [10] LAO DIGIT ZERO..LAO DIGIT NINE - {0x0EDC, 0x0EDF, prOLetter}, // Lo [4] LAO HO NO..LAO LETTER KHMU NYO - {0x0F00, 0x0F00, prOLetter}, // Lo TIBETAN SYLLABLE OM - {0x0F18, 0x0F19, prExtend}, // Mn [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS - {0x0F20, 0x0F29, prNumeric}, // Nd [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE - {0x0F35, 0x0F35, prExtend}, // Mn TIBETAN MARK NGAS BZUNG NYI ZLA - {0x0F37, 0x0F37, prExtend}, // Mn TIBETAN MARK NGAS BZUNG SGOR RTAGS - {0x0F39, 0x0F39, prExtend}, // Mn TIBETAN MARK TSA -PHRU - {0x0F3A, 0x0F3A, prClose}, // Ps TIBETAN MARK GUG RTAGS GYON - {0x0F3B, 0x0F3B, prClose}, // Pe TIBETAN MARK GUG RTAGS GYAS - {0x0F3C, 0x0F3C, prClose}, // Ps TIBETAN MARK ANG KHANG GYON - {0x0F3D, 0x0F3D, prClose}, // Pe TIBETAN MARK ANG KHANG GYAS - {0x0F3E, 0x0F3F, prExtend}, // Mc [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES - {0x0F40, 0x0F47, prOLetter}, // Lo [8] TIBETAN LETTER KA..TIBETAN LETTER JA - {0x0F49, 0x0F6C, prOLetter}, // Lo [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA - {0x0F71, 0x0F7E, prExtend}, // Mn [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO - {0x0F7F, 0x0F7F, prExtend}, // Mc TIBETAN SIGN RNAM BCAD - {0x0F80, 0x0F84, prExtend}, // Mn [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA - {0x0F86, 0x0F87, prExtend}, // Mn [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS - {0x0F88, 0x0F8C, prOLetter}, // Lo [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN - {0x0F8D, 0x0F97, prExtend}, // Mn [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA - {0x0F99, 0x0FBC, prExtend}, // Mn [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA - {0x0FC6, 0x0FC6, prExtend}, // Mn TIBETAN SYMBOL PADMA GDAN - {0x1000, 0x102A, prOLetter}, // Lo [43] MYANMAR LETTER KA..MYANMAR LETTER AU - {0x102B, 0x102C, prExtend}, // Mc [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA - {0x102D, 0x1030, prExtend}, // Mn [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU - {0x1031, 0x1031, prExtend}, // Mc MYANMAR VOWEL SIGN E - {0x1032, 0x1037, prExtend}, // Mn [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW - {0x1038, 0x1038, prExtend}, // Mc MYANMAR SIGN VISARGA - {0x1039, 0x103A, prExtend}, // Mn [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT - {0x103B, 0x103C, prExtend}, // Mc [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA - {0x103D, 0x103E, prExtend}, // Mn [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA - {0x103F, 0x103F, prOLetter}, // Lo MYANMAR LETTER GREAT SA - {0x1040, 0x1049, prNumeric}, // Nd [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE - {0x104A, 0x104B, prSTerm}, // Po [2] MYANMAR SIGN LITTLE SECTION..MYANMAR SIGN SECTION - {0x1050, 0x1055, prOLetter}, // Lo [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL - {0x1056, 0x1057, prExtend}, // Mc [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR - {0x1058, 0x1059, prExtend}, // Mn [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL - {0x105A, 0x105D, prOLetter}, // Lo [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE - {0x105E, 0x1060, prExtend}, // Mn [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA - {0x1061, 0x1061, prOLetter}, // Lo MYANMAR LETTER SGAW KAREN SHA - {0x1062, 0x1064, prExtend}, // Mc [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO - {0x1065, 0x1066, prOLetter}, // Lo [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA - {0x1067, 0x106D, prExtend}, // Mc [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5 - {0x106E, 0x1070, prOLetter}, // Lo [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA - {0x1071, 0x1074, prExtend}, // Mn [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE - {0x1075, 0x1081, prOLetter}, // Lo [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA - {0x1082, 0x1082, prExtend}, // Mn MYANMAR CONSONANT SIGN SHAN MEDIAL WA - {0x1083, 0x1084, prExtend}, // Mc [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E - {0x1085, 0x1086, prExtend}, // Mn [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y - {0x1087, 0x108C, prExtend}, // Mc [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3 - {0x108D, 0x108D, prExtend}, // Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE - {0x108E, 0x108E, prOLetter}, // Lo MYANMAR LETTER RUMAI PALAUNG FA - {0x108F, 0x108F, prExtend}, // Mc MYANMAR SIGN RUMAI PALAUNG TONE-5 - {0x1090, 0x1099, prNumeric}, // Nd [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE - {0x109A, 0x109C, prExtend}, // Mc [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A - {0x109D, 0x109D, prExtend}, // Mn MYANMAR VOWEL SIGN AITON AI - {0x10A0, 0x10C5, prUpper}, // L& [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE - {0x10C7, 0x10C7, prUpper}, // L& GEORGIAN CAPITAL LETTER YN - {0x10CD, 0x10CD, prUpper}, // L& GEORGIAN CAPITAL LETTER AEN - {0x10D0, 0x10FA, prOLetter}, // L& [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN - {0x10FC, 0x10FC, prLower}, // Lm MODIFIER LETTER GEORGIAN NAR - {0x10FD, 0x10FF, prOLetter}, // L& [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN - {0x1100, 0x1248, prOLetter}, // Lo [329] HANGUL CHOSEONG KIYEOK..ETHIOPIC SYLLABLE QWA - {0x124A, 0x124D, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE - {0x1250, 0x1256, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO - {0x1258, 0x1258, prOLetter}, // Lo ETHIOPIC SYLLABLE QHWA - {0x125A, 0x125D, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE - {0x1260, 0x1288, prOLetter}, // Lo [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA - {0x128A, 0x128D, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE - {0x1290, 0x12B0, prOLetter}, // Lo [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA - {0x12B2, 0x12B5, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE - {0x12B8, 0x12BE, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO - {0x12C0, 0x12C0, prOLetter}, // Lo ETHIOPIC SYLLABLE KXWA - {0x12C2, 0x12C5, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE - {0x12C8, 0x12D6, prOLetter}, // Lo [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O - {0x12D8, 0x1310, prOLetter}, // Lo [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA - {0x1312, 0x1315, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE - {0x1318, 0x135A, prOLetter}, // Lo [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA - {0x135D, 0x135F, prExtend}, // Mn [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK - {0x1362, 0x1362, prSTerm}, // Po ETHIOPIC FULL STOP - {0x1367, 0x1368, prSTerm}, // Po [2] ETHIOPIC QUESTION MARK..ETHIOPIC PARAGRAPH SEPARATOR - {0x1380, 0x138F, prOLetter}, // Lo [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE - {0x13A0, 0x13F5, prUpper}, // L& [86] CHEROKEE LETTER A..CHEROKEE LETTER MV - {0x13F8, 0x13FD, prLower}, // L& [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV - {0x1401, 0x166C, prOLetter}, // Lo [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA - {0x166E, 0x166E, prSTerm}, // Po CANADIAN SYLLABICS FULL STOP - {0x166F, 0x167F, prOLetter}, // Lo [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W - {0x1680, 0x1680, prSp}, // Zs OGHAM SPACE MARK - {0x1681, 0x169A, prOLetter}, // Lo [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH - {0x169B, 0x169B, prClose}, // Ps OGHAM FEATHER MARK - {0x169C, 0x169C, prClose}, // Pe OGHAM REVERSED FEATHER MARK - {0x16A0, 0x16EA, prOLetter}, // Lo [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X - {0x16EE, 0x16F0, prOLetter}, // Nl [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL - {0x16F1, 0x16F8, prOLetter}, // Lo [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC - {0x1700, 0x1711, prOLetter}, // Lo [18] TAGALOG LETTER A..TAGALOG LETTER HA - {0x1712, 0x1714, prExtend}, // Mn [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA - {0x1715, 0x1715, prExtend}, // Mc TAGALOG SIGN PAMUDPOD - {0x171F, 0x1731, prOLetter}, // Lo [19] TAGALOG LETTER ARCHAIC RA..HANUNOO LETTER HA - {0x1732, 0x1733, prExtend}, // Mn [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U - {0x1734, 0x1734, prExtend}, // Mc HANUNOO SIGN PAMUDPOD - {0x1735, 0x1736, prSTerm}, // Po [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION - {0x1740, 0x1751, prOLetter}, // Lo [18] BUHID LETTER A..BUHID LETTER HA - {0x1752, 0x1753, prExtend}, // Mn [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U - {0x1760, 0x176C, prOLetter}, // Lo [13] TAGBANWA LETTER A..TAGBANWA LETTER YA - {0x176E, 0x1770, prOLetter}, // Lo [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA - {0x1772, 0x1773, prExtend}, // Mn [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U - {0x1780, 0x17B3, prOLetter}, // Lo [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU - {0x17B4, 0x17B5, prExtend}, // Mn [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA - {0x17B6, 0x17B6, prExtend}, // Mc KHMER VOWEL SIGN AA - {0x17B7, 0x17BD, prExtend}, // Mn [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA - {0x17BE, 0x17C5, prExtend}, // Mc [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU - {0x17C6, 0x17C6, prExtend}, // Mn KHMER SIGN NIKAHIT - {0x17C7, 0x17C8, prExtend}, // Mc [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU - {0x17C9, 0x17D3, prExtend}, // Mn [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT - {0x17D7, 0x17D7, prOLetter}, // Lm KHMER SIGN LEK TOO - {0x17DC, 0x17DC, prOLetter}, // Lo KHMER SIGN AVAKRAHASANYA - {0x17DD, 0x17DD, prExtend}, // Mn KHMER SIGN ATTHACAN - {0x17E0, 0x17E9, prNumeric}, // Nd [10] KHMER DIGIT ZERO..KHMER DIGIT NINE - {0x1802, 0x1802, prSContinue}, // Po MONGOLIAN COMMA - {0x1803, 0x1803, prSTerm}, // Po MONGOLIAN FULL STOP - {0x1808, 0x1808, prSContinue}, // Po MONGOLIAN MANCHU COMMA - {0x1809, 0x1809, prSTerm}, // Po MONGOLIAN MANCHU FULL STOP - {0x180B, 0x180D, prExtend}, // Mn [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE - {0x180E, 0x180E, prFormat}, // Cf MONGOLIAN VOWEL SEPARATOR - {0x180F, 0x180F, prExtend}, // Mn MONGOLIAN FREE VARIATION SELECTOR FOUR - {0x1810, 0x1819, prNumeric}, // Nd [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE - {0x1820, 0x1842, prOLetter}, // Lo [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI - {0x1843, 0x1843, prOLetter}, // Lm MONGOLIAN LETTER TODO LONG VOWEL SIGN - {0x1844, 0x1878, prOLetter}, // Lo [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS - {0x1880, 0x1884, prOLetter}, // Lo [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA - {0x1885, 0x1886, prExtend}, // Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA - {0x1887, 0x18A8, prOLetter}, // Lo [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA - {0x18A9, 0x18A9, prExtend}, // Mn MONGOLIAN LETTER ALI GALI DAGALGA - {0x18AA, 0x18AA, prOLetter}, // Lo MONGOLIAN LETTER MANCHU ALI GALI LHA - {0x18B0, 0x18F5, prOLetter}, // Lo [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S - {0x1900, 0x191E, prOLetter}, // Lo [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA - {0x1920, 0x1922, prExtend}, // Mn [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U - {0x1923, 0x1926, prExtend}, // Mc [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU - {0x1927, 0x1928, prExtend}, // Mn [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O - {0x1929, 0x192B, prExtend}, // Mc [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA - {0x1930, 0x1931, prExtend}, // Mc [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA - {0x1932, 0x1932, prExtend}, // Mn LIMBU SMALL LETTER ANUSVARA - {0x1933, 0x1938, prExtend}, // Mc [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA - {0x1939, 0x193B, prExtend}, // Mn [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I - {0x1944, 0x1945, prSTerm}, // Po [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK - {0x1946, 0x194F, prNumeric}, // Nd [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE - {0x1950, 0x196D, prOLetter}, // Lo [30] TAI LE LETTER KA..TAI LE LETTER AI - {0x1970, 0x1974, prOLetter}, // Lo [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6 - {0x1980, 0x19AB, prOLetter}, // Lo [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA - {0x19B0, 0x19C9, prOLetter}, // Lo [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2 - {0x19D0, 0x19D9, prNumeric}, // Nd [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE - {0x1A00, 0x1A16, prOLetter}, // Lo [23] BUGINESE LETTER KA..BUGINESE LETTER HA - {0x1A17, 0x1A18, prExtend}, // Mn [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U - {0x1A19, 0x1A1A, prExtend}, // Mc [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O - {0x1A1B, 0x1A1B, prExtend}, // Mn BUGINESE VOWEL SIGN AE - {0x1A20, 0x1A54, prOLetter}, // Lo [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA - {0x1A55, 0x1A55, prExtend}, // Mc TAI THAM CONSONANT SIGN MEDIAL RA - {0x1A56, 0x1A56, prExtend}, // Mn TAI THAM CONSONANT SIGN MEDIAL LA - {0x1A57, 0x1A57, prExtend}, // Mc TAI THAM CONSONANT SIGN LA TANG LAI - {0x1A58, 0x1A5E, prExtend}, // Mn [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA - {0x1A60, 0x1A60, prExtend}, // Mn TAI THAM SIGN SAKOT - {0x1A61, 0x1A61, prExtend}, // Mc TAI THAM VOWEL SIGN A - {0x1A62, 0x1A62, prExtend}, // Mn TAI THAM VOWEL SIGN MAI SAT - {0x1A63, 0x1A64, prExtend}, // Mc [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA - {0x1A65, 0x1A6C, prExtend}, // Mn [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW - {0x1A6D, 0x1A72, prExtend}, // Mc [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI - {0x1A73, 0x1A7C, prExtend}, // Mn [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN - {0x1A7F, 0x1A7F, prExtend}, // Mn TAI THAM COMBINING CRYPTOGRAMMIC DOT - {0x1A80, 0x1A89, prNumeric}, // Nd [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE - {0x1A90, 0x1A99, prNumeric}, // Nd [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE - {0x1AA7, 0x1AA7, prOLetter}, // Lm TAI THAM SIGN MAI YAMOK - {0x1AA8, 0x1AAB, prSTerm}, // Po [4] TAI THAM SIGN KAAN..TAI THAM SIGN SATKAANKUU - {0x1AB0, 0x1ABD, prExtend}, // Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW - {0x1ABE, 0x1ABE, prExtend}, // Me COMBINING PARENTHESES OVERLAY - {0x1ABF, 0x1ACE, prExtend}, // Mn [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T - {0x1B00, 0x1B03, prExtend}, // Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG - {0x1B04, 0x1B04, prExtend}, // Mc BALINESE SIGN BISAH - {0x1B05, 0x1B33, prOLetter}, // Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA - {0x1B34, 0x1B34, prExtend}, // Mn BALINESE SIGN REREKAN - {0x1B35, 0x1B35, prExtend}, // Mc BALINESE VOWEL SIGN TEDUNG - {0x1B36, 0x1B3A, prExtend}, // Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA - {0x1B3B, 0x1B3B, prExtend}, // Mc BALINESE VOWEL SIGN RA REPA TEDUNG - {0x1B3C, 0x1B3C, prExtend}, // Mn BALINESE VOWEL SIGN LA LENGA - {0x1B3D, 0x1B41, prExtend}, // Mc [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG - {0x1B42, 0x1B42, prExtend}, // Mn BALINESE VOWEL SIGN PEPET - {0x1B43, 0x1B44, prExtend}, // Mc [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG - {0x1B45, 0x1B4C, prOLetter}, // Lo [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA - {0x1B50, 0x1B59, prNumeric}, // Nd [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE - {0x1B5A, 0x1B5B, prSTerm}, // Po [2] BALINESE PANTI..BALINESE PAMADA - {0x1B5E, 0x1B5F, prSTerm}, // Po [2] BALINESE CARIK SIKI..BALINESE CARIK PAREREN - {0x1B6B, 0x1B73, prExtend}, // Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG - {0x1B7D, 0x1B7E, prSTerm}, // Po [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG - {0x1B80, 0x1B81, prExtend}, // Mn [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR - {0x1B82, 0x1B82, prExtend}, // Mc SUNDANESE SIGN PANGWISAD - {0x1B83, 0x1BA0, prOLetter}, // Lo [30] SUNDANESE LETTER A..SUNDANESE LETTER HA - {0x1BA1, 0x1BA1, prExtend}, // Mc SUNDANESE CONSONANT SIGN PAMINGKAL - {0x1BA2, 0x1BA5, prExtend}, // Mn [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU - {0x1BA6, 0x1BA7, prExtend}, // Mc [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG - {0x1BA8, 0x1BA9, prExtend}, // Mn [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG - {0x1BAA, 0x1BAA, prExtend}, // Mc SUNDANESE SIGN PAMAAEH - {0x1BAB, 0x1BAD, prExtend}, // Mn [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA - {0x1BAE, 0x1BAF, prOLetter}, // Lo [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA - {0x1BB0, 0x1BB9, prNumeric}, // Nd [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE - {0x1BBA, 0x1BE5, prOLetter}, // Lo [44] SUNDANESE AVAGRAHA..BATAK LETTER U - {0x1BE6, 0x1BE6, prExtend}, // Mn BATAK SIGN TOMPI - {0x1BE7, 0x1BE7, prExtend}, // Mc BATAK VOWEL SIGN E - {0x1BE8, 0x1BE9, prExtend}, // Mn [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE - {0x1BEA, 0x1BEC, prExtend}, // Mc [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O - {0x1BED, 0x1BED, prExtend}, // Mn BATAK VOWEL SIGN KARO O - {0x1BEE, 0x1BEE, prExtend}, // Mc BATAK VOWEL SIGN U - {0x1BEF, 0x1BF1, prExtend}, // Mn [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H - {0x1BF2, 0x1BF3, prExtend}, // Mc [2] BATAK PANGOLAT..BATAK PANONGONAN - {0x1C00, 0x1C23, prOLetter}, // Lo [36] LEPCHA LETTER KA..LEPCHA LETTER A - {0x1C24, 0x1C2B, prExtend}, // Mc [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU - {0x1C2C, 0x1C33, prExtend}, // Mn [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T - {0x1C34, 0x1C35, prExtend}, // Mc [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG - {0x1C36, 0x1C37, prExtend}, // Mn [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA - {0x1C3B, 0x1C3C, prSTerm}, // Po [2] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION NYET THYOOM TA-ROL - {0x1C40, 0x1C49, prNumeric}, // Nd [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE - {0x1C4D, 0x1C4F, prOLetter}, // Lo [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA - {0x1C50, 0x1C59, prNumeric}, // Nd [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE - {0x1C5A, 0x1C77, prOLetter}, // Lo [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH - {0x1C78, 0x1C7D, prOLetter}, // Lm [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD - {0x1C7E, 0x1C7F, prSTerm}, // Po [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD - {0x1C80, 0x1C88, prLower}, // L& [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK - {0x1C90, 0x1CBA, prOLetter}, // L& [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN - {0x1CBD, 0x1CBF, prOLetter}, // L& [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN - {0x1CD0, 0x1CD2, prExtend}, // Mn [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA - {0x1CD4, 0x1CE0, prExtend}, // Mn [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA - {0x1CE1, 0x1CE1, prExtend}, // Mc VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA - {0x1CE2, 0x1CE8, prExtend}, // Mn [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL - {0x1CE9, 0x1CEC, prOLetter}, // Lo [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL - {0x1CED, 0x1CED, prExtend}, // Mn VEDIC SIGN TIRYAK - {0x1CEE, 0x1CF3, prOLetter}, // Lo [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA - {0x1CF4, 0x1CF4, prExtend}, // Mn VEDIC TONE CANDRA ABOVE - {0x1CF5, 0x1CF6, prOLetter}, // Lo [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA - {0x1CF7, 0x1CF7, prExtend}, // Mc VEDIC SIGN ATIKRAMA - {0x1CF8, 0x1CF9, prExtend}, // Mn [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE - {0x1CFA, 0x1CFA, prOLetter}, // Lo VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA - {0x1D00, 0x1D2B, prLower}, // L& [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL - {0x1D2C, 0x1D6A, prLower}, // Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI - {0x1D6B, 0x1D77, prLower}, // L& [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G - {0x1D78, 0x1D78, prLower}, // Lm MODIFIER LETTER CYRILLIC EN - {0x1D79, 0x1D9A, prLower}, // L& [34] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK - {0x1D9B, 0x1DBF, prLower}, // Lm [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA - {0x1DC0, 0x1DFF, prExtend}, // Mn [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW - {0x1E00, 0x1E00, prUpper}, // L& LATIN CAPITAL LETTER A WITH RING BELOW - {0x1E01, 0x1E01, prLower}, // L& LATIN SMALL LETTER A WITH RING BELOW - {0x1E02, 0x1E02, prUpper}, // L& LATIN CAPITAL LETTER B WITH DOT ABOVE - {0x1E03, 0x1E03, prLower}, // L& LATIN SMALL LETTER B WITH DOT ABOVE - {0x1E04, 0x1E04, prUpper}, // L& LATIN CAPITAL LETTER B WITH DOT BELOW - {0x1E05, 0x1E05, prLower}, // L& LATIN SMALL LETTER B WITH DOT BELOW - {0x1E06, 0x1E06, prUpper}, // L& LATIN CAPITAL LETTER B WITH LINE BELOW - {0x1E07, 0x1E07, prLower}, // L& LATIN SMALL LETTER B WITH LINE BELOW - {0x1E08, 0x1E08, prUpper}, // L& LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE - {0x1E09, 0x1E09, prLower}, // L& LATIN SMALL LETTER C WITH CEDILLA AND ACUTE - {0x1E0A, 0x1E0A, prUpper}, // L& LATIN CAPITAL LETTER D WITH DOT ABOVE - {0x1E0B, 0x1E0B, prLower}, // L& LATIN SMALL LETTER D WITH DOT ABOVE - {0x1E0C, 0x1E0C, prUpper}, // L& LATIN CAPITAL LETTER D WITH DOT BELOW - {0x1E0D, 0x1E0D, prLower}, // L& LATIN SMALL LETTER D WITH DOT BELOW - {0x1E0E, 0x1E0E, prUpper}, // L& LATIN CAPITAL LETTER D WITH LINE BELOW - {0x1E0F, 0x1E0F, prLower}, // L& LATIN SMALL LETTER D WITH LINE BELOW - {0x1E10, 0x1E10, prUpper}, // L& LATIN CAPITAL LETTER D WITH CEDILLA - {0x1E11, 0x1E11, prLower}, // L& LATIN SMALL LETTER D WITH CEDILLA - {0x1E12, 0x1E12, prUpper}, // L& LATIN CAPITAL LETTER D WITH CIRCUMFLEX BELOW - {0x1E13, 0x1E13, prLower}, // L& LATIN SMALL LETTER D WITH CIRCUMFLEX BELOW - {0x1E14, 0x1E14, prUpper}, // L& LATIN CAPITAL LETTER E WITH MACRON AND GRAVE - {0x1E15, 0x1E15, prLower}, // L& LATIN SMALL LETTER E WITH MACRON AND GRAVE - {0x1E16, 0x1E16, prUpper}, // L& LATIN CAPITAL LETTER E WITH MACRON AND ACUTE - {0x1E17, 0x1E17, prLower}, // L& LATIN SMALL LETTER E WITH MACRON AND ACUTE - {0x1E18, 0x1E18, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX BELOW - {0x1E19, 0x1E19, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX BELOW - {0x1E1A, 0x1E1A, prUpper}, // L& LATIN CAPITAL LETTER E WITH TILDE BELOW - {0x1E1B, 0x1E1B, prLower}, // L& LATIN SMALL LETTER E WITH TILDE BELOW - {0x1E1C, 0x1E1C, prUpper}, // L& LATIN CAPITAL LETTER E WITH CEDILLA AND BREVE - {0x1E1D, 0x1E1D, prLower}, // L& LATIN SMALL LETTER E WITH CEDILLA AND BREVE - {0x1E1E, 0x1E1E, prUpper}, // L& LATIN CAPITAL LETTER F WITH DOT ABOVE - {0x1E1F, 0x1E1F, prLower}, // L& LATIN SMALL LETTER F WITH DOT ABOVE - {0x1E20, 0x1E20, prUpper}, // L& LATIN CAPITAL LETTER G WITH MACRON - {0x1E21, 0x1E21, prLower}, // L& LATIN SMALL LETTER G WITH MACRON - {0x1E22, 0x1E22, prUpper}, // L& LATIN CAPITAL LETTER H WITH DOT ABOVE - {0x1E23, 0x1E23, prLower}, // L& LATIN SMALL LETTER H WITH DOT ABOVE - {0x1E24, 0x1E24, prUpper}, // L& LATIN CAPITAL LETTER H WITH DOT BELOW - {0x1E25, 0x1E25, prLower}, // L& LATIN SMALL LETTER H WITH DOT BELOW - {0x1E26, 0x1E26, prUpper}, // L& LATIN CAPITAL LETTER H WITH DIAERESIS - {0x1E27, 0x1E27, prLower}, // L& LATIN SMALL LETTER H WITH DIAERESIS - {0x1E28, 0x1E28, prUpper}, // L& LATIN CAPITAL LETTER H WITH CEDILLA - {0x1E29, 0x1E29, prLower}, // L& LATIN SMALL LETTER H WITH CEDILLA - {0x1E2A, 0x1E2A, prUpper}, // L& LATIN CAPITAL LETTER H WITH BREVE BELOW - {0x1E2B, 0x1E2B, prLower}, // L& LATIN SMALL LETTER H WITH BREVE BELOW - {0x1E2C, 0x1E2C, prUpper}, // L& LATIN CAPITAL LETTER I WITH TILDE BELOW - {0x1E2D, 0x1E2D, prLower}, // L& LATIN SMALL LETTER I WITH TILDE BELOW - {0x1E2E, 0x1E2E, prUpper}, // L& LATIN CAPITAL LETTER I WITH DIAERESIS AND ACUTE - {0x1E2F, 0x1E2F, prLower}, // L& LATIN SMALL LETTER I WITH DIAERESIS AND ACUTE - {0x1E30, 0x1E30, prUpper}, // L& LATIN CAPITAL LETTER K WITH ACUTE - {0x1E31, 0x1E31, prLower}, // L& LATIN SMALL LETTER K WITH ACUTE - {0x1E32, 0x1E32, prUpper}, // L& LATIN CAPITAL LETTER K WITH DOT BELOW - {0x1E33, 0x1E33, prLower}, // L& LATIN SMALL LETTER K WITH DOT BELOW - {0x1E34, 0x1E34, prUpper}, // L& LATIN CAPITAL LETTER K WITH LINE BELOW - {0x1E35, 0x1E35, prLower}, // L& LATIN SMALL LETTER K WITH LINE BELOW - {0x1E36, 0x1E36, prUpper}, // L& LATIN CAPITAL LETTER L WITH DOT BELOW - {0x1E37, 0x1E37, prLower}, // L& LATIN SMALL LETTER L WITH DOT BELOW - {0x1E38, 0x1E38, prUpper}, // L& LATIN CAPITAL LETTER L WITH DOT BELOW AND MACRON - {0x1E39, 0x1E39, prLower}, // L& LATIN SMALL LETTER L WITH DOT BELOW AND MACRON - {0x1E3A, 0x1E3A, prUpper}, // L& LATIN CAPITAL LETTER L WITH LINE BELOW - {0x1E3B, 0x1E3B, prLower}, // L& LATIN SMALL LETTER L WITH LINE BELOW - {0x1E3C, 0x1E3C, prUpper}, // L& LATIN CAPITAL LETTER L WITH CIRCUMFLEX BELOW - {0x1E3D, 0x1E3D, prLower}, // L& LATIN SMALL LETTER L WITH CIRCUMFLEX BELOW - {0x1E3E, 0x1E3E, prUpper}, // L& LATIN CAPITAL LETTER M WITH ACUTE - {0x1E3F, 0x1E3F, prLower}, // L& LATIN SMALL LETTER M WITH ACUTE - {0x1E40, 0x1E40, prUpper}, // L& LATIN CAPITAL LETTER M WITH DOT ABOVE - {0x1E41, 0x1E41, prLower}, // L& LATIN SMALL LETTER M WITH DOT ABOVE - {0x1E42, 0x1E42, prUpper}, // L& LATIN CAPITAL LETTER M WITH DOT BELOW - {0x1E43, 0x1E43, prLower}, // L& LATIN SMALL LETTER M WITH DOT BELOW - {0x1E44, 0x1E44, prUpper}, // L& LATIN CAPITAL LETTER N WITH DOT ABOVE - {0x1E45, 0x1E45, prLower}, // L& LATIN SMALL LETTER N WITH DOT ABOVE - {0x1E46, 0x1E46, prUpper}, // L& LATIN CAPITAL LETTER N WITH DOT BELOW - {0x1E47, 0x1E47, prLower}, // L& LATIN SMALL LETTER N WITH DOT BELOW - {0x1E48, 0x1E48, prUpper}, // L& LATIN CAPITAL LETTER N WITH LINE BELOW - {0x1E49, 0x1E49, prLower}, // L& LATIN SMALL LETTER N WITH LINE BELOW - {0x1E4A, 0x1E4A, prUpper}, // L& LATIN CAPITAL LETTER N WITH CIRCUMFLEX BELOW - {0x1E4B, 0x1E4B, prLower}, // L& LATIN SMALL LETTER N WITH CIRCUMFLEX BELOW - {0x1E4C, 0x1E4C, prUpper}, // L& LATIN CAPITAL LETTER O WITH TILDE AND ACUTE - {0x1E4D, 0x1E4D, prLower}, // L& LATIN SMALL LETTER O WITH TILDE AND ACUTE - {0x1E4E, 0x1E4E, prUpper}, // L& LATIN CAPITAL LETTER O WITH TILDE AND DIAERESIS - {0x1E4F, 0x1E4F, prLower}, // L& LATIN SMALL LETTER O WITH TILDE AND DIAERESIS - {0x1E50, 0x1E50, prUpper}, // L& LATIN CAPITAL LETTER O WITH MACRON AND GRAVE - {0x1E51, 0x1E51, prLower}, // L& LATIN SMALL LETTER O WITH MACRON AND GRAVE - {0x1E52, 0x1E52, prUpper}, // L& LATIN CAPITAL LETTER O WITH MACRON AND ACUTE - {0x1E53, 0x1E53, prLower}, // L& LATIN SMALL LETTER O WITH MACRON AND ACUTE - {0x1E54, 0x1E54, prUpper}, // L& LATIN CAPITAL LETTER P WITH ACUTE - {0x1E55, 0x1E55, prLower}, // L& LATIN SMALL LETTER P WITH ACUTE - {0x1E56, 0x1E56, prUpper}, // L& LATIN CAPITAL LETTER P WITH DOT ABOVE - {0x1E57, 0x1E57, prLower}, // L& LATIN SMALL LETTER P WITH DOT ABOVE - {0x1E58, 0x1E58, prUpper}, // L& LATIN CAPITAL LETTER R WITH DOT ABOVE - {0x1E59, 0x1E59, prLower}, // L& LATIN SMALL LETTER R WITH DOT ABOVE - {0x1E5A, 0x1E5A, prUpper}, // L& LATIN CAPITAL LETTER R WITH DOT BELOW - {0x1E5B, 0x1E5B, prLower}, // L& LATIN SMALL LETTER R WITH DOT BELOW - {0x1E5C, 0x1E5C, prUpper}, // L& LATIN CAPITAL LETTER R WITH DOT BELOW AND MACRON - {0x1E5D, 0x1E5D, prLower}, // L& LATIN SMALL LETTER R WITH DOT BELOW AND MACRON - {0x1E5E, 0x1E5E, prUpper}, // L& LATIN CAPITAL LETTER R WITH LINE BELOW - {0x1E5F, 0x1E5F, prLower}, // L& LATIN SMALL LETTER R WITH LINE BELOW - {0x1E60, 0x1E60, prUpper}, // L& LATIN CAPITAL LETTER S WITH DOT ABOVE - {0x1E61, 0x1E61, prLower}, // L& LATIN SMALL LETTER S WITH DOT ABOVE - {0x1E62, 0x1E62, prUpper}, // L& LATIN CAPITAL LETTER S WITH DOT BELOW - {0x1E63, 0x1E63, prLower}, // L& LATIN SMALL LETTER S WITH DOT BELOW - {0x1E64, 0x1E64, prUpper}, // L& LATIN CAPITAL LETTER S WITH ACUTE AND DOT ABOVE - {0x1E65, 0x1E65, prLower}, // L& LATIN SMALL LETTER S WITH ACUTE AND DOT ABOVE - {0x1E66, 0x1E66, prUpper}, // L& LATIN CAPITAL LETTER S WITH CARON AND DOT ABOVE - {0x1E67, 0x1E67, prLower}, // L& LATIN SMALL LETTER S WITH CARON AND DOT ABOVE - {0x1E68, 0x1E68, prUpper}, // L& LATIN CAPITAL LETTER S WITH DOT BELOW AND DOT ABOVE - {0x1E69, 0x1E69, prLower}, // L& LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE - {0x1E6A, 0x1E6A, prUpper}, // L& LATIN CAPITAL LETTER T WITH DOT ABOVE - {0x1E6B, 0x1E6B, prLower}, // L& LATIN SMALL LETTER T WITH DOT ABOVE - {0x1E6C, 0x1E6C, prUpper}, // L& LATIN CAPITAL LETTER T WITH DOT BELOW - {0x1E6D, 0x1E6D, prLower}, // L& LATIN SMALL LETTER T WITH DOT BELOW - {0x1E6E, 0x1E6E, prUpper}, // L& LATIN CAPITAL LETTER T WITH LINE BELOW - {0x1E6F, 0x1E6F, prLower}, // L& LATIN SMALL LETTER T WITH LINE BELOW - {0x1E70, 0x1E70, prUpper}, // L& LATIN CAPITAL LETTER T WITH CIRCUMFLEX BELOW - {0x1E71, 0x1E71, prLower}, // L& LATIN SMALL LETTER T WITH CIRCUMFLEX BELOW - {0x1E72, 0x1E72, prUpper}, // L& LATIN CAPITAL LETTER U WITH DIAERESIS BELOW - {0x1E73, 0x1E73, prLower}, // L& LATIN SMALL LETTER U WITH DIAERESIS BELOW - {0x1E74, 0x1E74, prUpper}, // L& LATIN CAPITAL LETTER U WITH TILDE BELOW - {0x1E75, 0x1E75, prLower}, // L& LATIN SMALL LETTER U WITH TILDE BELOW - {0x1E76, 0x1E76, prUpper}, // L& LATIN CAPITAL LETTER U WITH CIRCUMFLEX BELOW - {0x1E77, 0x1E77, prLower}, // L& LATIN SMALL LETTER U WITH CIRCUMFLEX BELOW - {0x1E78, 0x1E78, prUpper}, // L& LATIN CAPITAL LETTER U WITH TILDE AND ACUTE - {0x1E79, 0x1E79, prLower}, // L& LATIN SMALL LETTER U WITH TILDE AND ACUTE - {0x1E7A, 0x1E7A, prUpper}, // L& LATIN CAPITAL LETTER U WITH MACRON AND DIAERESIS - {0x1E7B, 0x1E7B, prLower}, // L& LATIN SMALL LETTER U WITH MACRON AND DIAERESIS - {0x1E7C, 0x1E7C, prUpper}, // L& LATIN CAPITAL LETTER V WITH TILDE - {0x1E7D, 0x1E7D, prLower}, // L& LATIN SMALL LETTER V WITH TILDE - {0x1E7E, 0x1E7E, prUpper}, // L& LATIN CAPITAL LETTER V WITH DOT BELOW - {0x1E7F, 0x1E7F, prLower}, // L& LATIN SMALL LETTER V WITH DOT BELOW - {0x1E80, 0x1E80, prUpper}, // L& LATIN CAPITAL LETTER W WITH GRAVE - {0x1E81, 0x1E81, prLower}, // L& LATIN SMALL LETTER W WITH GRAVE - {0x1E82, 0x1E82, prUpper}, // L& LATIN CAPITAL LETTER W WITH ACUTE - {0x1E83, 0x1E83, prLower}, // L& LATIN SMALL LETTER W WITH ACUTE - {0x1E84, 0x1E84, prUpper}, // L& LATIN CAPITAL LETTER W WITH DIAERESIS - {0x1E85, 0x1E85, prLower}, // L& LATIN SMALL LETTER W WITH DIAERESIS - {0x1E86, 0x1E86, prUpper}, // L& LATIN CAPITAL LETTER W WITH DOT ABOVE - {0x1E87, 0x1E87, prLower}, // L& LATIN SMALL LETTER W WITH DOT ABOVE - {0x1E88, 0x1E88, prUpper}, // L& LATIN CAPITAL LETTER W WITH DOT BELOW - {0x1E89, 0x1E89, prLower}, // L& LATIN SMALL LETTER W WITH DOT BELOW - {0x1E8A, 0x1E8A, prUpper}, // L& LATIN CAPITAL LETTER X WITH DOT ABOVE - {0x1E8B, 0x1E8B, prLower}, // L& LATIN SMALL LETTER X WITH DOT ABOVE - {0x1E8C, 0x1E8C, prUpper}, // L& LATIN CAPITAL LETTER X WITH DIAERESIS - {0x1E8D, 0x1E8D, prLower}, // L& LATIN SMALL LETTER X WITH DIAERESIS - {0x1E8E, 0x1E8E, prUpper}, // L& LATIN CAPITAL LETTER Y WITH DOT ABOVE - {0x1E8F, 0x1E8F, prLower}, // L& LATIN SMALL LETTER Y WITH DOT ABOVE - {0x1E90, 0x1E90, prUpper}, // L& LATIN CAPITAL LETTER Z WITH CIRCUMFLEX - {0x1E91, 0x1E91, prLower}, // L& LATIN SMALL LETTER Z WITH CIRCUMFLEX - {0x1E92, 0x1E92, prUpper}, // L& LATIN CAPITAL LETTER Z WITH DOT BELOW - {0x1E93, 0x1E93, prLower}, // L& LATIN SMALL LETTER Z WITH DOT BELOW - {0x1E94, 0x1E94, prUpper}, // L& LATIN CAPITAL LETTER Z WITH LINE BELOW - {0x1E95, 0x1E9D, prLower}, // L& [9] LATIN SMALL LETTER Z WITH LINE BELOW..LATIN SMALL LETTER LONG S WITH HIGH STROKE - {0x1E9E, 0x1E9E, prUpper}, // L& LATIN CAPITAL LETTER SHARP S - {0x1E9F, 0x1E9F, prLower}, // L& LATIN SMALL LETTER DELTA - {0x1EA0, 0x1EA0, prUpper}, // L& LATIN CAPITAL LETTER A WITH DOT BELOW - {0x1EA1, 0x1EA1, prLower}, // L& LATIN SMALL LETTER A WITH DOT BELOW - {0x1EA2, 0x1EA2, prUpper}, // L& LATIN CAPITAL LETTER A WITH HOOK ABOVE - {0x1EA3, 0x1EA3, prLower}, // L& LATIN SMALL LETTER A WITH HOOK ABOVE - {0x1EA4, 0x1EA4, prUpper}, // L& LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE - {0x1EA5, 0x1EA5, prLower}, // L& LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE - {0x1EA6, 0x1EA6, prUpper}, // L& LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE - {0x1EA7, 0x1EA7, prLower}, // L& LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE - {0x1EA8, 0x1EA8, prUpper}, // L& LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE - {0x1EA9, 0x1EA9, prLower}, // L& LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE - {0x1EAA, 0x1EAA, prUpper}, // L& LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE - {0x1EAB, 0x1EAB, prLower}, // L& LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE - {0x1EAC, 0x1EAC, prUpper}, // L& LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW - {0x1EAD, 0x1EAD, prLower}, // L& LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW - {0x1EAE, 0x1EAE, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE AND ACUTE - {0x1EAF, 0x1EAF, prLower}, // L& LATIN SMALL LETTER A WITH BREVE AND ACUTE - {0x1EB0, 0x1EB0, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE AND GRAVE - {0x1EB1, 0x1EB1, prLower}, // L& LATIN SMALL LETTER A WITH BREVE AND GRAVE - {0x1EB2, 0x1EB2, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE - {0x1EB3, 0x1EB3, prLower}, // L& LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE - {0x1EB4, 0x1EB4, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE AND TILDE - {0x1EB5, 0x1EB5, prLower}, // L& LATIN SMALL LETTER A WITH BREVE AND TILDE - {0x1EB6, 0x1EB6, prUpper}, // L& LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW - {0x1EB7, 0x1EB7, prLower}, // L& LATIN SMALL LETTER A WITH BREVE AND DOT BELOW - {0x1EB8, 0x1EB8, prUpper}, // L& LATIN CAPITAL LETTER E WITH DOT BELOW - {0x1EB9, 0x1EB9, prLower}, // L& LATIN SMALL LETTER E WITH DOT BELOW - {0x1EBA, 0x1EBA, prUpper}, // L& LATIN CAPITAL LETTER E WITH HOOK ABOVE - {0x1EBB, 0x1EBB, prLower}, // L& LATIN SMALL LETTER E WITH HOOK ABOVE - {0x1EBC, 0x1EBC, prUpper}, // L& LATIN CAPITAL LETTER E WITH TILDE - {0x1EBD, 0x1EBD, prLower}, // L& LATIN SMALL LETTER E WITH TILDE - {0x1EBE, 0x1EBE, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE - {0x1EBF, 0x1EBF, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE - {0x1EC0, 0x1EC0, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE - {0x1EC1, 0x1EC1, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE - {0x1EC2, 0x1EC2, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE - {0x1EC3, 0x1EC3, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE - {0x1EC4, 0x1EC4, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE - {0x1EC5, 0x1EC5, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE - {0x1EC6, 0x1EC6, prUpper}, // L& LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW - {0x1EC7, 0x1EC7, prLower}, // L& LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW - {0x1EC8, 0x1EC8, prUpper}, // L& LATIN CAPITAL LETTER I WITH HOOK ABOVE - {0x1EC9, 0x1EC9, prLower}, // L& LATIN SMALL LETTER I WITH HOOK ABOVE - {0x1ECA, 0x1ECA, prUpper}, // L& LATIN CAPITAL LETTER I WITH DOT BELOW - {0x1ECB, 0x1ECB, prLower}, // L& LATIN SMALL LETTER I WITH DOT BELOW - {0x1ECC, 0x1ECC, prUpper}, // L& LATIN CAPITAL LETTER O WITH DOT BELOW - {0x1ECD, 0x1ECD, prLower}, // L& LATIN SMALL LETTER O WITH DOT BELOW - {0x1ECE, 0x1ECE, prUpper}, // L& LATIN CAPITAL LETTER O WITH HOOK ABOVE - {0x1ECF, 0x1ECF, prLower}, // L& LATIN SMALL LETTER O WITH HOOK ABOVE - {0x1ED0, 0x1ED0, prUpper}, // L& LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE - {0x1ED1, 0x1ED1, prLower}, // L& LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE - {0x1ED2, 0x1ED2, prUpper}, // L& LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE - {0x1ED3, 0x1ED3, prLower}, // L& LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE - {0x1ED4, 0x1ED4, prUpper}, // L& LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE - {0x1ED5, 0x1ED5, prLower}, // L& LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE - {0x1ED6, 0x1ED6, prUpper}, // L& LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE - {0x1ED7, 0x1ED7, prLower}, // L& LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE - {0x1ED8, 0x1ED8, prUpper}, // L& LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW - {0x1ED9, 0x1ED9, prLower}, // L& LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW - {0x1EDA, 0x1EDA, prUpper}, // L& LATIN CAPITAL LETTER O WITH HORN AND ACUTE - {0x1EDB, 0x1EDB, prLower}, // L& LATIN SMALL LETTER O WITH HORN AND ACUTE - {0x1EDC, 0x1EDC, prUpper}, // L& LATIN CAPITAL LETTER O WITH HORN AND GRAVE - {0x1EDD, 0x1EDD, prLower}, // L& LATIN SMALL LETTER O WITH HORN AND GRAVE - {0x1EDE, 0x1EDE, prUpper}, // L& LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE - {0x1EDF, 0x1EDF, prLower}, // L& LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE - {0x1EE0, 0x1EE0, prUpper}, // L& LATIN CAPITAL LETTER O WITH HORN AND TILDE - {0x1EE1, 0x1EE1, prLower}, // L& LATIN SMALL LETTER O WITH HORN AND TILDE - {0x1EE2, 0x1EE2, prUpper}, // L& LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW - {0x1EE3, 0x1EE3, prLower}, // L& LATIN SMALL LETTER O WITH HORN AND DOT BELOW - {0x1EE4, 0x1EE4, prUpper}, // L& LATIN CAPITAL LETTER U WITH DOT BELOW - {0x1EE5, 0x1EE5, prLower}, // L& LATIN SMALL LETTER U WITH DOT BELOW - {0x1EE6, 0x1EE6, prUpper}, // L& LATIN CAPITAL LETTER U WITH HOOK ABOVE - {0x1EE7, 0x1EE7, prLower}, // L& LATIN SMALL LETTER U WITH HOOK ABOVE - {0x1EE8, 0x1EE8, prUpper}, // L& LATIN CAPITAL LETTER U WITH HORN AND ACUTE - {0x1EE9, 0x1EE9, prLower}, // L& LATIN SMALL LETTER U WITH HORN AND ACUTE - {0x1EEA, 0x1EEA, prUpper}, // L& LATIN CAPITAL LETTER U WITH HORN AND GRAVE - {0x1EEB, 0x1EEB, prLower}, // L& LATIN SMALL LETTER U WITH HORN AND GRAVE - {0x1EEC, 0x1EEC, prUpper}, // L& LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE - {0x1EED, 0x1EED, prLower}, // L& LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE - {0x1EEE, 0x1EEE, prUpper}, // L& LATIN CAPITAL LETTER U WITH HORN AND TILDE - {0x1EEF, 0x1EEF, prLower}, // L& LATIN SMALL LETTER U WITH HORN AND TILDE - {0x1EF0, 0x1EF0, prUpper}, // L& LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW - {0x1EF1, 0x1EF1, prLower}, // L& LATIN SMALL LETTER U WITH HORN AND DOT BELOW - {0x1EF2, 0x1EF2, prUpper}, // L& LATIN CAPITAL LETTER Y WITH GRAVE - {0x1EF3, 0x1EF3, prLower}, // L& LATIN SMALL LETTER Y WITH GRAVE - {0x1EF4, 0x1EF4, prUpper}, // L& LATIN CAPITAL LETTER Y WITH DOT BELOW - {0x1EF5, 0x1EF5, prLower}, // L& LATIN SMALL LETTER Y WITH DOT BELOW - {0x1EF6, 0x1EF6, prUpper}, // L& LATIN CAPITAL LETTER Y WITH HOOK ABOVE - {0x1EF7, 0x1EF7, prLower}, // L& LATIN SMALL LETTER Y WITH HOOK ABOVE - {0x1EF8, 0x1EF8, prUpper}, // L& LATIN CAPITAL LETTER Y WITH TILDE - {0x1EF9, 0x1EF9, prLower}, // L& LATIN SMALL LETTER Y WITH TILDE - {0x1EFA, 0x1EFA, prUpper}, // L& LATIN CAPITAL LETTER MIDDLE-WELSH LL - {0x1EFB, 0x1EFB, prLower}, // L& LATIN SMALL LETTER MIDDLE-WELSH LL - {0x1EFC, 0x1EFC, prUpper}, // L& LATIN CAPITAL LETTER MIDDLE-WELSH V - {0x1EFD, 0x1EFD, prLower}, // L& LATIN SMALL LETTER MIDDLE-WELSH V - {0x1EFE, 0x1EFE, prUpper}, // L& LATIN CAPITAL LETTER Y WITH LOOP - {0x1EFF, 0x1F07, prLower}, // L& [9] LATIN SMALL LETTER Y WITH LOOP..GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI - {0x1F08, 0x1F0F, prUpper}, // L& [8] GREEK CAPITAL LETTER ALPHA WITH PSILI..GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI - {0x1F10, 0x1F15, prLower}, // L& [6] GREEK SMALL LETTER EPSILON WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA - {0x1F18, 0x1F1D, prUpper}, // L& [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA - {0x1F20, 0x1F27, prLower}, // L& [8] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI - {0x1F28, 0x1F2F, prUpper}, // L& [8] GREEK CAPITAL LETTER ETA WITH PSILI..GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI - {0x1F30, 0x1F37, prLower}, // L& [8] GREEK SMALL LETTER IOTA WITH PSILI..GREEK SMALL LETTER IOTA WITH DASIA AND PERISPOMENI - {0x1F38, 0x1F3F, prUpper}, // L& [8] GREEK CAPITAL LETTER IOTA WITH PSILI..GREEK CAPITAL LETTER IOTA WITH DASIA AND PERISPOMENI - {0x1F40, 0x1F45, prLower}, // L& [6] GREEK SMALL LETTER OMICRON WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA - {0x1F48, 0x1F4D, prUpper}, // L& [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA - {0x1F50, 0x1F57, prLower}, // L& [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI - {0x1F59, 0x1F59, prUpper}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA - {0x1F5B, 0x1F5B, prUpper}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA - {0x1F5D, 0x1F5D, prUpper}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA - {0x1F5F, 0x1F5F, prUpper}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI - {0x1F60, 0x1F67, prLower}, // L& [8] GREEK SMALL LETTER OMEGA WITH PSILI..GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI - {0x1F68, 0x1F6F, prUpper}, // L& [8] GREEK CAPITAL LETTER OMEGA WITH PSILI..GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI - {0x1F70, 0x1F7D, prLower}, // L& [14] GREEK SMALL LETTER ALPHA WITH VARIA..GREEK SMALL LETTER OMEGA WITH OXIA - {0x1F80, 0x1F87, prLower}, // L& [8] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI - {0x1F88, 0x1F8F, prUpper}, // L& [8] GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI..GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI - {0x1F90, 0x1F97, prLower}, // L& [8] GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI - {0x1F98, 0x1F9F, prUpper}, // L& [8] GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI..GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI - {0x1FA0, 0x1FA7, prLower}, // L& [8] GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI - {0x1FA8, 0x1FAF, prUpper}, // L& [8] GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI..GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI - {0x1FB0, 0x1FB4, prLower}, // L& [5] GREEK SMALL LETTER ALPHA WITH VRACHY..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI - {0x1FB6, 0x1FB7, prLower}, // L& [2] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI - {0x1FB8, 0x1FBC, prUpper}, // L& [5] GREEK CAPITAL LETTER ALPHA WITH VRACHY..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI - {0x1FBE, 0x1FBE, prLower}, // L& GREEK PROSGEGRAMMENI - {0x1FC2, 0x1FC4, prLower}, // L& [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI - {0x1FC6, 0x1FC7, prLower}, // L& [2] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI - {0x1FC8, 0x1FCC, prUpper}, // L& [5] GREEK CAPITAL LETTER EPSILON WITH VARIA..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI - {0x1FD0, 0x1FD3, prLower}, // L& [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA - {0x1FD6, 0x1FD7, prLower}, // L& [2] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI - {0x1FD8, 0x1FDB, prUpper}, // L& [4] GREEK CAPITAL LETTER IOTA WITH VRACHY..GREEK CAPITAL LETTER IOTA WITH OXIA - {0x1FE0, 0x1FE7, prLower}, // L& [8] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI - {0x1FE8, 0x1FEC, prUpper}, // L& [5] GREEK CAPITAL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA - {0x1FF2, 0x1FF4, prLower}, // L& [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI - {0x1FF6, 0x1FF7, prLower}, // L& [2] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI - {0x1FF8, 0x1FFC, prUpper}, // L& [5] GREEK CAPITAL LETTER OMICRON WITH VARIA..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI - {0x2000, 0x200A, prSp}, // Zs [11] EN QUAD..HAIR SPACE - {0x200B, 0x200B, prFormat}, // Cf ZERO WIDTH SPACE - {0x200C, 0x200D, prExtend}, // Cf [2] ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER - {0x200E, 0x200F, prFormat}, // Cf [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK - {0x2013, 0x2014, prSContinue}, // Pd [2] EN DASH..EM DASH - {0x2018, 0x2018, prClose}, // Pi LEFT SINGLE QUOTATION MARK - {0x2019, 0x2019, prClose}, // Pf RIGHT SINGLE QUOTATION MARK - {0x201A, 0x201A, prClose}, // Ps SINGLE LOW-9 QUOTATION MARK - {0x201B, 0x201C, prClose}, // Pi [2] SINGLE HIGH-REVERSED-9 QUOTATION MARK..LEFT DOUBLE QUOTATION MARK - {0x201D, 0x201D, prClose}, // Pf RIGHT DOUBLE QUOTATION MARK - {0x201E, 0x201E, prClose}, // Ps DOUBLE LOW-9 QUOTATION MARK - {0x201F, 0x201F, prClose}, // Pi DOUBLE HIGH-REVERSED-9 QUOTATION MARK - {0x2024, 0x2024, prATerm}, // Po ONE DOT LEADER - {0x2028, 0x2028, prSep}, // Zl LINE SEPARATOR - {0x2029, 0x2029, prSep}, // Zp PARAGRAPH SEPARATOR - {0x202A, 0x202E, prFormat}, // Cf [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE - {0x202F, 0x202F, prSp}, // Zs NARROW NO-BREAK SPACE - {0x2039, 0x2039, prClose}, // Pi SINGLE LEFT-POINTING ANGLE QUOTATION MARK - {0x203A, 0x203A, prClose}, // Pf SINGLE RIGHT-POINTING ANGLE QUOTATION MARK - {0x203C, 0x203D, prSTerm}, // Po [2] DOUBLE EXCLAMATION MARK..INTERROBANG - {0x2045, 0x2045, prClose}, // Ps LEFT SQUARE BRACKET WITH QUILL - {0x2046, 0x2046, prClose}, // Pe RIGHT SQUARE BRACKET WITH QUILL - {0x2047, 0x2049, prSTerm}, // Po [3] DOUBLE QUESTION MARK..EXCLAMATION QUESTION MARK - {0x205F, 0x205F, prSp}, // Zs MEDIUM MATHEMATICAL SPACE - {0x2060, 0x2064, prFormat}, // Cf [5] WORD JOINER..INVISIBLE PLUS - {0x2066, 0x206F, prFormat}, // Cf [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES - {0x2071, 0x2071, prLower}, // Lm SUPERSCRIPT LATIN SMALL LETTER I - {0x207D, 0x207D, prClose}, // Ps SUPERSCRIPT LEFT PARENTHESIS - {0x207E, 0x207E, prClose}, // Pe SUPERSCRIPT RIGHT PARENTHESIS - {0x207F, 0x207F, prLower}, // Lm SUPERSCRIPT LATIN SMALL LETTER N - {0x208D, 0x208D, prClose}, // Ps SUBSCRIPT LEFT PARENTHESIS - {0x208E, 0x208E, prClose}, // Pe SUBSCRIPT RIGHT PARENTHESIS - {0x2090, 0x209C, prLower}, // Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T - {0x20D0, 0x20DC, prExtend}, // Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE - {0x20DD, 0x20E0, prExtend}, // Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH - {0x20E1, 0x20E1, prExtend}, // Mn COMBINING LEFT RIGHT ARROW ABOVE - {0x20E2, 0x20E4, prExtend}, // Me [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE - {0x20E5, 0x20F0, prExtend}, // Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE - {0x2102, 0x2102, prUpper}, // L& DOUBLE-STRUCK CAPITAL C - {0x2107, 0x2107, prUpper}, // L& EULER CONSTANT - {0x210A, 0x210A, prLower}, // L& SCRIPT SMALL G - {0x210B, 0x210D, prUpper}, // L& [3] SCRIPT CAPITAL H..DOUBLE-STRUCK CAPITAL H - {0x210E, 0x210F, prLower}, // L& [2] PLANCK CONSTANT..PLANCK CONSTANT OVER TWO PI - {0x2110, 0x2112, prUpper}, // L& [3] SCRIPT CAPITAL I..SCRIPT CAPITAL L - {0x2113, 0x2113, prLower}, // L& SCRIPT SMALL L - {0x2115, 0x2115, prUpper}, // L& DOUBLE-STRUCK CAPITAL N - {0x2119, 0x211D, prUpper}, // L& [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R - {0x2124, 0x2124, prUpper}, // L& DOUBLE-STRUCK CAPITAL Z - {0x2126, 0x2126, prUpper}, // L& OHM SIGN - {0x2128, 0x2128, prUpper}, // L& BLACK-LETTER CAPITAL Z - {0x212A, 0x212D, prUpper}, // L& [4] KELVIN SIGN..BLACK-LETTER CAPITAL C - {0x212F, 0x212F, prLower}, // L& SCRIPT SMALL E - {0x2130, 0x2133, prUpper}, // L& [4] SCRIPT CAPITAL E..SCRIPT CAPITAL M - {0x2134, 0x2134, prLower}, // L& SCRIPT SMALL O - {0x2135, 0x2138, prOLetter}, // Lo [4] ALEF SYMBOL..DALET SYMBOL - {0x2139, 0x2139, prLower}, // L& INFORMATION SOURCE - {0x213C, 0x213D, prLower}, // L& [2] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK SMALL GAMMA - {0x213E, 0x213F, prUpper}, // L& [2] DOUBLE-STRUCK CAPITAL GAMMA..DOUBLE-STRUCK CAPITAL PI - {0x2145, 0x2145, prUpper}, // L& DOUBLE-STRUCK ITALIC CAPITAL D - {0x2146, 0x2149, prLower}, // L& [4] DOUBLE-STRUCK ITALIC SMALL D..DOUBLE-STRUCK ITALIC SMALL J - {0x214E, 0x214E, prLower}, // L& TURNED SMALL F - {0x2160, 0x216F, prUpper}, // Nl [16] ROMAN NUMERAL ONE..ROMAN NUMERAL ONE THOUSAND - {0x2170, 0x217F, prLower}, // Nl [16] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL ONE THOUSAND - {0x2180, 0x2182, prOLetter}, // Nl [3] ROMAN NUMERAL ONE THOUSAND C D..ROMAN NUMERAL TEN THOUSAND - {0x2183, 0x2183, prUpper}, // L& ROMAN NUMERAL REVERSED ONE HUNDRED - {0x2184, 0x2184, prLower}, // L& LATIN SMALL LETTER REVERSED C - {0x2185, 0x2188, prOLetter}, // Nl [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND - {0x2308, 0x2308, prClose}, // Ps LEFT CEILING - {0x2309, 0x2309, prClose}, // Pe RIGHT CEILING - {0x230A, 0x230A, prClose}, // Ps LEFT FLOOR - {0x230B, 0x230B, prClose}, // Pe RIGHT FLOOR - {0x2329, 0x2329, prClose}, // Ps LEFT-POINTING ANGLE BRACKET - {0x232A, 0x232A, prClose}, // Pe RIGHT-POINTING ANGLE BRACKET - {0x24B6, 0x24CF, prUpper}, // So [26] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN CAPITAL LETTER Z - {0x24D0, 0x24E9, prLower}, // So [26] CIRCLED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z - {0x275B, 0x2760, prClose}, // So [6] HEAVY SINGLE TURNED COMMA QUOTATION MARK ORNAMENT..HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT - {0x2768, 0x2768, prClose}, // Ps MEDIUM LEFT PARENTHESIS ORNAMENT - {0x2769, 0x2769, prClose}, // Pe MEDIUM RIGHT PARENTHESIS ORNAMENT - {0x276A, 0x276A, prClose}, // Ps MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT - {0x276B, 0x276B, prClose}, // Pe MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT - {0x276C, 0x276C, prClose}, // Ps MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x276D, 0x276D, prClose}, // Pe MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x276E, 0x276E, prClose}, // Ps HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x276F, 0x276F, prClose}, // Pe HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT - {0x2770, 0x2770, prClose}, // Ps HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT - {0x2771, 0x2771, prClose}, // Pe HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT - {0x2772, 0x2772, prClose}, // Ps LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT - {0x2773, 0x2773, prClose}, // Pe LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT - {0x2774, 0x2774, prClose}, // Ps MEDIUM LEFT CURLY BRACKET ORNAMENT - {0x2775, 0x2775, prClose}, // Pe MEDIUM RIGHT CURLY BRACKET ORNAMENT - {0x27C5, 0x27C5, prClose}, // Ps LEFT S-SHAPED BAG DELIMITER - {0x27C6, 0x27C6, prClose}, // Pe RIGHT S-SHAPED BAG DELIMITER - {0x27E6, 0x27E6, prClose}, // Ps MATHEMATICAL LEFT WHITE SQUARE BRACKET - {0x27E7, 0x27E7, prClose}, // Pe MATHEMATICAL RIGHT WHITE SQUARE BRACKET - {0x27E8, 0x27E8, prClose}, // Ps MATHEMATICAL LEFT ANGLE BRACKET - {0x27E9, 0x27E9, prClose}, // Pe MATHEMATICAL RIGHT ANGLE BRACKET - {0x27EA, 0x27EA, prClose}, // Ps MATHEMATICAL LEFT DOUBLE ANGLE BRACKET - {0x27EB, 0x27EB, prClose}, // Pe MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET - {0x27EC, 0x27EC, prClose}, // Ps MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET - {0x27ED, 0x27ED, prClose}, // Pe MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET - {0x27EE, 0x27EE, prClose}, // Ps MATHEMATICAL LEFT FLATTENED PARENTHESIS - {0x27EF, 0x27EF, prClose}, // Pe MATHEMATICAL RIGHT FLATTENED PARENTHESIS - {0x2983, 0x2983, prClose}, // Ps LEFT WHITE CURLY BRACKET - {0x2984, 0x2984, prClose}, // Pe RIGHT WHITE CURLY BRACKET - {0x2985, 0x2985, prClose}, // Ps LEFT WHITE PARENTHESIS - {0x2986, 0x2986, prClose}, // Pe RIGHT WHITE PARENTHESIS - {0x2987, 0x2987, prClose}, // Ps Z NOTATION LEFT IMAGE BRACKET - {0x2988, 0x2988, prClose}, // Pe Z NOTATION RIGHT IMAGE BRACKET - {0x2989, 0x2989, prClose}, // Ps Z NOTATION LEFT BINDING BRACKET - {0x298A, 0x298A, prClose}, // Pe Z NOTATION RIGHT BINDING BRACKET - {0x298B, 0x298B, prClose}, // Ps LEFT SQUARE BRACKET WITH UNDERBAR - {0x298C, 0x298C, prClose}, // Pe RIGHT SQUARE BRACKET WITH UNDERBAR - {0x298D, 0x298D, prClose}, // Ps LEFT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x298E, 0x298E, prClose}, // Pe RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x298F, 0x298F, prClose}, // Ps LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER - {0x2990, 0x2990, prClose}, // Pe RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER - {0x2991, 0x2991, prClose}, // Ps LEFT ANGLE BRACKET WITH DOT - {0x2992, 0x2992, prClose}, // Pe RIGHT ANGLE BRACKET WITH DOT - {0x2993, 0x2993, prClose}, // Ps LEFT ARC LESS-THAN BRACKET - {0x2994, 0x2994, prClose}, // Pe RIGHT ARC GREATER-THAN BRACKET - {0x2995, 0x2995, prClose}, // Ps DOUBLE LEFT ARC GREATER-THAN BRACKET - {0x2996, 0x2996, prClose}, // Pe DOUBLE RIGHT ARC LESS-THAN BRACKET - {0x2997, 0x2997, prClose}, // Ps LEFT BLACK TORTOISE SHELL BRACKET - {0x2998, 0x2998, prClose}, // Pe RIGHT BLACK TORTOISE SHELL BRACKET - {0x29D8, 0x29D8, prClose}, // Ps LEFT WIGGLY FENCE - {0x29D9, 0x29D9, prClose}, // Pe RIGHT WIGGLY FENCE - {0x29DA, 0x29DA, prClose}, // Ps LEFT DOUBLE WIGGLY FENCE - {0x29DB, 0x29DB, prClose}, // Pe RIGHT DOUBLE WIGGLY FENCE - {0x29FC, 0x29FC, prClose}, // Ps LEFT-POINTING CURVED ANGLE BRACKET - {0x29FD, 0x29FD, prClose}, // Pe RIGHT-POINTING CURVED ANGLE BRACKET - {0x2C00, 0x2C2F, prUpper}, // L& [48] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC CAPITAL LETTER CAUDATE CHRIVI - {0x2C30, 0x2C5F, prLower}, // L& [48] GLAGOLITIC SMALL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI - {0x2C60, 0x2C60, prUpper}, // L& LATIN CAPITAL LETTER L WITH DOUBLE BAR - {0x2C61, 0x2C61, prLower}, // L& LATIN SMALL LETTER L WITH DOUBLE BAR - {0x2C62, 0x2C64, prUpper}, // L& [3] LATIN CAPITAL LETTER L WITH MIDDLE TILDE..LATIN CAPITAL LETTER R WITH TAIL - {0x2C65, 0x2C66, prLower}, // L& [2] LATIN SMALL LETTER A WITH STROKE..LATIN SMALL LETTER T WITH DIAGONAL STROKE - {0x2C67, 0x2C67, prUpper}, // L& LATIN CAPITAL LETTER H WITH DESCENDER - {0x2C68, 0x2C68, prLower}, // L& LATIN SMALL LETTER H WITH DESCENDER - {0x2C69, 0x2C69, prUpper}, // L& LATIN CAPITAL LETTER K WITH DESCENDER - {0x2C6A, 0x2C6A, prLower}, // L& LATIN SMALL LETTER K WITH DESCENDER - {0x2C6B, 0x2C6B, prUpper}, // L& LATIN CAPITAL LETTER Z WITH DESCENDER - {0x2C6C, 0x2C6C, prLower}, // L& LATIN SMALL LETTER Z WITH DESCENDER - {0x2C6D, 0x2C70, prUpper}, // L& [4] LATIN CAPITAL LETTER ALPHA..LATIN CAPITAL LETTER TURNED ALPHA - {0x2C71, 0x2C71, prLower}, // L& LATIN SMALL LETTER V WITH RIGHT HOOK - {0x2C72, 0x2C72, prUpper}, // L& LATIN CAPITAL LETTER W WITH HOOK - {0x2C73, 0x2C74, prLower}, // L& [2] LATIN SMALL LETTER W WITH HOOK..LATIN SMALL LETTER V WITH CURL - {0x2C75, 0x2C75, prUpper}, // L& LATIN CAPITAL LETTER HALF H - {0x2C76, 0x2C7B, prLower}, // L& [6] LATIN SMALL LETTER HALF H..LATIN LETTER SMALL CAPITAL TURNED E - {0x2C7C, 0x2C7D, prLower}, // Lm [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V - {0x2C7E, 0x2C80, prUpper}, // L& [3] LATIN CAPITAL LETTER S WITH SWASH TAIL..COPTIC CAPITAL LETTER ALFA - {0x2C81, 0x2C81, prLower}, // L& COPTIC SMALL LETTER ALFA - {0x2C82, 0x2C82, prUpper}, // L& COPTIC CAPITAL LETTER VIDA - {0x2C83, 0x2C83, prLower}, // L& COPTIC SMALL LETTER VIDA - {0x2C84, 0x2C84, prUpper}, // L& COPTIC CAPITAL LETTER GAMMA - {0x2C85, 0x2C85, prLower}, // L& COPTIC SMALL LETTER GAMMA - {0x2C86, 0x2C86, prUpper}, // L& COPTIC CAPITAL LETTER DALDA - {0x2C87, 0x2C87, prLower}, // L& COPTIC SMALL LETTER DALDA - {0x2C88, 0x2C88, prUpper}, // L& COPTIC CAPITAL LETTER EIE - {0x2C89, 0x2C89, prLower}, // L& COPTIC SMALL LETTER EIE - {0x2C8A, 0x2C8A, prUpper}, // L& COPTIC CAPITAL LETTER SOU - {0x2C8B, 0x2C8B, prLower}, // L& COPTIC SMALL LETTER SOU - {0x2C8C, 0x2C8C, prUpper}, // L& COPTIC CAPITAL LETTER ZATA - {0x2C8D, 0x2C8D, prLower}, // L& COPTIC SMALL LETTER ZATA - {0x2C8E, 0x2C8E, prUpper}, // L& COPTIC CAPITAL LETTER HATE - {0x2C8F, 0x2C8F, prLower}, // L& COPTIC SMALL LETTER HATE - {0x2C90, 0x2C90, prUpper}, // L& COPTIC CAPITAL LETTER THETHE - {0x2C91, 0x2C91, prLower}, // L& COPTIC SMALL LETTER THETHE - {0x2C92, 0x2C92, prUpper}, // L& COPTIC CAPITAL LETTER IAUDA - {0x2C93, 0x2C93, prLower}, // L& COPTIC SMALL LETTER IAUDA - {0x2C94, 0x2C94, prUpper}, // L& COPTIC CAPITAL LETTER KAPA - {0x2C95, 0x2C95, prLower}, // L& COPTIC SMALL LETTER KAPA - {0x2C96, 0x2C96, prUpper}, // L& COPTIC CAPITAL LETTER LAULA - {0x2C97, 0x2C97, prLower}, // L& COPTIC SMALL LETTER LAULA - {0x2C98, 0x2C98, prUpper}, // L& COPTIC CAPITAL LETTER MI - {0x2C99, 0x2C99, prLower}, // L& COPTIC SMALL LETTER MI - {0x2C9A, 0x2C9A, prUpper}, // L& COPTIC CAPITAL LETTER NI - {0x2C9B, 0x2C9B, prLower}, // L& COPTIC SMALL LETTER NI - {0x2C9C, 0x2C9C, prUpper}, // L& COPTIC CAPITAL LETTER KSI - {0x2C9D, 0x2C9D, prLower}, // L& COPTIC SMALL LETTER KSI - {0x2C9E, 0x2C9E, prUpper}, // L& COPTIC CAPITAL LETTER O - {0x2C9F, 0x2C9F, prLower}, // L& COPTIC SMALL LETTER O - {0x2CA0, 0x2CA0, prUpper}, // L& COPTIC CAPITAL LETTER PI - {0x2CA1, 0x2CA1, prLower}, // L& COPTIC SMALL LETTER PI - {0x2CA2, 0x2CA2, prUpper}, // L& COPTIC CAPITAL LETTER RO - {0x2CA3, 0x2CA3, prLower}, // L& COPTIC SMALL LETTER RO - {0x2CA4, 0x2CA4, prUpper}, // L& COPTIC CAPITAL LETTER SIMA - {0x2CA5, 0x2CA5, prLower}, // L& COPTIC SMALL LETTER SIMA - {0x2CA6, 0x2CA6, prUpper}, // L& COPTIC CAPITAL LETTER TAU - {0x2CA7, 0x2CA7, prLower}, // L& COPTIC SMALL LETTER TAU - {0x2CA8, 0x2CA8, prUpper}, // L& COPTIC CAPITAL LETTER UA - {0x2CA9, 0x2CA9, prLower}, // L& COPTIC SMALL LETTER UA - {0x2CAA, 0x2CAA, prUpper}, // L& COPTIC CAPITAL LETTER FI - {0x2CAB, 0x2CAB, prLower}, // L& COPTIC SMALL LETTER FI - {0x2CAC, 0x2CAC, prUpper}, // L& COPTIC CAPITAL LETTER KHI - {0x2CAD, 0x2CAD, prLower}, // L& COPTIC SMALL LETTER KHI - {0x2CAE, 0x2CAE, prUpper}, // L& COPTIC CAPITAL LETTER PSI - {0x2CAF, 0x2CAF, prLower}, // L& COPTIC SMALL LETTER PSI - {0x2CB0, 0x2CB0, prUpper}, // L& COPTIC CAPITAL LETTER OOU - {0x2CB1, 0x2CB1, prLower}, // L& COPTIC SMALL LETTER OOU - {0x2CB2, 0x2CB2, prUpper}, // L& COPTIC CAPITAL LETTER DIALECT-P ALEF - {0x2CB3, 0x2CB3, prLower}, // L& COPTIC SMALL LETTER DIALECT-P ALEF - {0x2CB4, 0x2CB4, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC AIN - {0x2CB5, 0x2CB5, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC AIN - {0x2CB6, 0x2CB6, prUpper}, // L& COPTIC CAPITAL LETTER CRYPTOGRAMMIC EIE - {0x2CB7, 0x2CB7, prLower}, // L& COPTIC SMALL LETTER CRYPTOGRAMMIC EIE - {0x2CB8, 0x2CB8, prUpper}, // L& COPTIC CAPITAL LETTER DIALECT-P KAPA - {0x2CB9, 0x2CB9, prLower}, // L& COPTIC SMALL LETTER DIALECT-P KAPA - {0x2CBA, 0x2CBA, prUpper}, // L& COPTIC CAPITAL LETTER DIALECT-P NI - {0x2CBB, 0x2CBB, prLower}, // L& COPTIC SMALL LETTER DIALECT-P NI - {0x2CBC, 0x2CBC, prUpper}, // L& COPTIC CAPITAL LETTER CRYPTOGRAMMIC NI - {0x2CBD, 0x2CBD, prLower}, // L& COPTIC SMALL LETTER CRYPTOGRAMMIC NI - {0x2CBE, 0x2CBE, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC OOU - {0x2CBF, 0x2CBF, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC OOU - {0x2CC0, 0x2CC0, prUpper}, // L& COPTIC CAPITAL LETTER SAMPI - {0x2CC1, 0x2CC1, prLower}, // L& COPTIC SMALL LETTER SAMPI - {0x2CC2, 0x2CC2, prUpper}, // L& COPTIC CAPITAL LETTER CROSSED SHEI - {0x2CC3, 0x2CC3, prLower}, // L& COPTIC SMALL LETTER CROSSED SHEI - {0x2CC4, 0x2CC4, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC SHEI - {0x2CC5, 0x2CC5, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC SHEI - {0x2CC6, 0x2CC6, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC ESH - {0x2CC7, 0x2CC7, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC ESH - {0x2CC8, 0x2CC8, prUpper}, // L& COPTIC CAPITAL LETTER AKHMIMIC KHEI - {0x2CC9, 0x2CC9, prLower}, // L& COPTIC SMALL LETTER AKHMIMIC KHEI - {0x2CCA, 0x2CCA, prUpper}, // L& COPTIC CAPITAL LETTER DIALECT-P HORI - {0x2CCB, 0x2CCB, prLower}, // L& COPTIC SMALL LETTER DIALECT-P HORI - {0x2CCC, 0x2CCC, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC HORI - {0x2CCD, 0x2CCD, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC HORI - {0x2CCE, 0x2CCE, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC HA - {0x2CCF, 0x2CCF, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC HA - {0x2CD0, 0x2CD0, prUpper}, // L& COPTIC CAPITAL LETTER L-SHAPED HA - {0x2CD1, 0x2CD1, prLower}, // L& COPTIC SMALL LETTER L-SHAPED HA - {0x2CD2, 0x2CD2, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC HEI - {0x2CD3, 0x2CD3, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC HEI - {0x2CD4, 0x2CD4, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC HAT - {0x2CD5, 0x2CD5, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC HAT - {0x2CD6, 0x2CD6, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC GANGIA - {0x2CD7, 0x2CD7, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC GANGIA - {0x2CD8, 0x2CD8, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC DJA - {0x2CD9, 0x2CD9, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC DJA - {0x2CDA, 0x2CDA, prUpper}, // L& COPTIC CAPITAL LETTER OLD COPTIC SHIMA - {0x2CDB, 0x2CDB, prLower}, // L& COPTIC SMALL LETTER OLD COPTIC SHIMA - {0x2CDC, 0x2CDC, prUpper}, // L& COPTIC CAPITAL LETTER OLD NUBIAN SHIMA - {0x2CDD, 0x2CDD, prLower}, // L& COPTIC SMALL LETTER OLD NUBIAN SHIMA - {0x2CDE, 0x2CDE, prUpper}, // L& COPTIC CAPITAL LETTER OLD NUBIAN NGI - {0x2CDF, 0x2CDF, prLower}, // L& COPTIC SMALL LETTER OLD NUBIAN NGI - {0x2CE0, 0x2CE0, prUpper}, // L& COPTIC CAPITAL LETTER OLD NUBIAN NYI - {0x2CE1, 0x2CE1, prLower}, // L& COPTIC SMALL LETTER OLD NUBIAN NYI - {0x2CE2, 0x2CE2, prUpper}, // L& COPTIC CAPITAL LETTER OLD NUBIAN WAU - {0x2CE3, 0x2CE4, prLower}, // L& [2] COPTIC SMALL LETTER OLD NUBIAN WAU..COPTIC SYMBOL KAI - {0x2CEB, 0x2CEB, prUpper}, // L& COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI - {0x2CEC, 0x2CEC, prLower}, // L& COPTIC SMALL LETTER CRYPTOGRAMMIC SHEI - {0x2CED, 0x2CED, prUpper}, // L& COPTIC CAPITAL LETTER CRYPTOGRAMMIC GANGIA - {0x2CEE, 0x2CEE, prLower}, // L& COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA - {0x2CEF, 0x2CF1, prExtend}, // Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS - {0x2CF2, 0x2CF2, prUpper}, // L& COPTIC CAPITAL LETTER BOHAIRIC KHEI - {0x2CF3, 0x2CF3, prLower}, // L& COPTIC SMALL LETTER BOHAIRIC KHEI - {0x2D00, 0x2D25, prLower}, // L& [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE - {0x2D27, 0x2D27, prLower}, // L& GEORGIAN SMALL LETTER YN - {0x2D2D, 0x2D2D, prLower}, // L& GEORGIAN SMALL LETTER AEN - {0x2D30, 0x2D67, prOLetter}, // Lo [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO - {0x2D6F, 0x2D6F, prOLetter}, // Lm TIFINAGH MODIFIER LETTER LABIALIZATION MARK - {0x2D7F, 0x2D7F, prExtend}, // Mn TIFINAGH CONSONANT JOINER - {0x2D80, 0x2D96, prOLetter}, // Lo [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE - {0x2DA0, 0x2DA6, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO - {0x2DA8, 0x2DAE, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO - {0x2DB0, 0x2DB6, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO - {0x2DB8, 0x2DBE, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO - {0x2DC0, 0x2DC6, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO - {0x2DC8, 0x2DCE, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO - {0x2DD0, 0x2DD6, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO - {0x2DD8, 0x2DDE, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO - {0x2DE0, 0x2DFF, prExtend}, // Mn [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS - {0x2E00, 0x2E01, prClose}, // Po [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER - {0x2E02, 0x2E02, prClose}, // Pi LEFT SUBSTITUTION BRACKET - {0x2E03, 0x2E03, prClose}, // Pf RIGHT SUBSTITUTION BRACKET - {0x2E04, 0x2E04, prClose}, // Pi LEFT DOTTED SUBSTITUTION BRACKET - {0x2E05, 0x2E05, prClose}, // Pf RIGHT DOTTED SUBSTITUTION BRACKET - {0x2E06, 0x2E08, prClose}, // Po [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER - {0x2E09, 0x2E09, prClose}, // Pi LEFT TRANSPOSITION BRACKET - {0x2E0A, 0x2E0A, prClose}, // Pf RIGHT TRANSPOSITION BRACKET - {0x2E0B, 0x2E0B, prClose}, // Po RAISED SQUARE - {0x2E0C, 0x2E0C, prClose}, // Pi LEFT RAISED OMISSION BRACKET - {0x2E0D, 0x2E0D, prClose}, // Pf RIGHT RAISED OMISSION BRACKET - {0x2E1C, 0x2E1C, prClose}, // Pi LEFT LOW PARAPHRASE BRACKET - {0x2E1D, 0x2E1D, prClose}, // Pf RIGHT LOW PARAPHRASE BRACKET - {0x2E20, 0x2E20, prClose}, // Pi LEFT VERTICAL BAR WITH QUILL - {0x2E21, 0x2E21, prClose}, // Pf RIGHT VERTICAL BAR WITH QUILL - {0x2E22, 0x2E22, prClose}, // Ps TOP LEFT HALF BRACKET - {0x2E23, 0x2E23, prClose}, // Pe TOP RIGHT HALF BRACKET - {0x2E24, 0x2E24, prClose}, // Ps BOTTOM LEFT HALF BRACKET - {0x2E25, 0x2E25, prClose}, // Pe BOTTOM RIGHT HALF BRACKET - {0x2E26, 0x2E26, prClose}, // Ps LEFT SIDEWAYS U BRACKET - {0x2E27, 0x2E27, prClose}, // Pe RIGHT SIDEWAYS U BRACKET - {0x2E28, 0x2E28, prClose}, // Ps LEFT DOUBLE PARENTHESIS - {0x2E29, 0x2E29, prClose}, // Pe RIGHT DOUBLE PARENTHESIS - {0x2E2E, 0x2E2E, prSTerm}, // Po REVERSED QUESTION MARK - {0x2E2F, 0x2E2F, prOLetter}, // Lm VERTICAL TILDE - {0x2E3C, 0x2E3C, prSTerm}, // Po STENOGRAPHIC FULL STOP - {0x2E42, 0x2E42, prClose}, // Ps DOUBLE LOW-REVERSED-9 QUOTATION MARK - {0x2E53, 0x2E54, prSTerm}, // Po [2] MEDIEVAL EXCLAMATION MARK..MEDIEVAL QUESTION MARK - {0x2E55, 0x2E55, prClose}, // Ps LEFT SQUARE BRACKET WITH STROKE - {0x2E56, 0x2E56, prClose}, // Pe RIGHT SQUARE BRACKET WITH STROKE - {0x2E57, 0x2E57, prClose}, // Ps LEFT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E58, 0x2E58, prClose}, // Pe RIGHT SQUARE BRACKET WITH DOUBLE STROKE - {0x2E59, 0x2E59, prClose}, // Ps TOP HALF LEFT PARENTHESIS - {0x2E5A, 0x2E5A, prClose}, // Pe TOP HALF RIGHT PARENTHESIS - {0x2E5B, 0x2E5B, prClose}, // Ps BOTTOM HALF LEFT PARENTHESIS - {0x2E5C, 0x2E5C, prClose}, // Pe BOTTOM HALF RIGHT PARENTHESIS - {0x3000, 0x3000, prSp}, // Zs IDEOGRAPHIC SPACE - {0x3001, 0x3001, prSContinue}, // Po IDEOGRAPHIC COMMA - {0x3002, 0x3002, prSTerm}, // Po IDEOGRAPHIC FULL STOP - {0x3005, 0x3005, prOLetter}, // Lm IDEOGRAPHIC ITERATION MARK - {0x3006, 0x3006, prOLetter}, // Lo IDEOGRAPHIC CLOSING MARK - {0x3007, 0x3007, prOLetter}, // Nl IDEOGRAPHIC NUMBER ZERO - {0x3008, 0x3008, prClose}, // Ps LEFT ANGLE BRACKET - {0x3009, 0x3009, prClose}, // Pe RIGHT ANGLE BRACKET - {0x300A, 0x300A, prClose}, // Ps LEFT DOUBLE ANGLE BRACKET - {0x300B, 0x300B, prClose}, // Pe RIGHT DOUBLE ANGLE BRACKET - {0x300C, 0x300C, prClose}, // Ps LEFT CORNER BRACKET - {0x300D, 0x300D, prClose}, // Pe RIGHT CORNER BRACKET - {0x300E, 0x300E, prClose}, // Ps LEFT WHITE CORNER BRACKET - {0x300F, 0x300F, prClose}, // Pe RIGHT WHITE CORNER BRACKET - {0x3010, 0x3010, prClose}, // Ps LEFT BLACK LENTICULAR BRACKET - {0x3011, 0x3011, prClose}, // Pe RIGHT BLACK LENTICULAR BRACKET - {0x3014, 0x3014, prClose}, // Ps LEFT TORTOISE SHELL BRACKET - {0x3015, 0x3015, prClose}, // Pe RIGHT TORTOISE SHELL BRACKET - {0x3016, 0x3016, prClose}, // Ps LEFT WHITE LENTICULAR BRACKET - {0x3017, 0x3017, prClose}, // Pe RIGHT WHITE LENTICULAR BRACKET - {0x3018, 0x3018, prClose}, // Ps LEFT WHITE TORTOISE SHELL BRACKET - {0x3019, 0x3019, prClose}, // Pe RIGHT WHITE TORTOISE SHELL BRACKET - {0x301A, 0x301A, prClose}, // Ps LEFT WHITE SQUARE BRACKET - {0x301B, 0x301B, prClose}, // Pe RIGHT WHITE SQUARE BRACKET - {0x301D, 0x301D, prClose}, // Ps REVERSED DOUBLE PRIME QUOTATION MARK - {0x301E, 0x301F, prClose}, // Pe [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK - {0x3021, 0x3029, prOLetter}, // Nl [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE - {0x302A, 0x302D, prExtend}, // Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK - {0x302E, 0x302F, prExtend}, // Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK - {0x3031, 0x3035, prOLetter}, // Lm [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF - {0x3038, 0x303A, prOLetter}, // Nl [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY - {0x303B, 0x303B, prOLetter}, // Lm VERTICAL IDEOGRAPHIC ITERATION MARK - {0x303C, 0x303C, prOLetter}, // Lo MASU MARK - {0x3041, 0x3096, prOLetter}, // Lo [86] HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE - {0x3099, 0x309A, prExtend}, // Mn [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309D, 0x309E, prOLetter}, // Lm [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK - {0x309F, 0x309F, prOLetter}, // Lo HIRAGANA DIGRAPH YORI - {0x30A1, 0x30FA, prOLetter}, // Lo [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO - {0x30FC, 0x30FE, prOLetter}, // Lm [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK - {0x30FF, 0x30FF, prOLetter}, // Lo KATAKANA DIGRAPH KOTO - {0x3105, 0x312F, prOLetter}, // Lo [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN - {0x3131, 0x318E, prOLetter}, // Lo [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE - {0x31A0, 0x31BF, prOLetter}, // Lo [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH - {0x31F0, 0x31FF, prOLetter}, // Lo [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO - {0x3400, 0x4DBF, prOLetter}, // Lo [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF - {0x4E00, 0xA014, prOLetter}, // Lo [21013] CJK UNIFIED IDEOGRAPH-4E00..YI SYLLABLE E - {0xA015, 0xA015, prOLetter}, // Lm YI SYLLABLE WU - {0xA016, 0xA48C, prOLetter}, // Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR - {0xA4D0, 0xA4F7, prOLetter}, // Lo [40] LISU LETTER BA..LISU LETTER OE - {0xA4F8, 0xA4FD, prOLetter}, // Lm [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU - {0xA4FF, 0xA4FF, prSTerm}, // Po LISU PUNCTUATION FULL STOP - {0xA500, 0xA60B, prOLetter}, // Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG - {0xA60C, 0xA60C, prOLetter}, // Lm VAI SYLLABLE LENGTHENER - {0xA60E, 0xA60F, prSTerm}, // Po [2] VAI FULL STOP..VAI QUESTION MARK - {0xA610, 0xA61F, prOLetter}, // Lo [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG - {0xA620, 0xA629, prNumeric}, // Nd [10] VAI DIGIT ZERO..VAI DIGIT NINE - {0xA62A, 0xA62B, prOLetter}, // Lo [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO - {0xA640, 0xA640, prUpper}, // L& CYRILLIC CAPITAL LETTER ZEMLYA - {0xA641, 0xA641, prLower}, // L& CYRILLIC SMALL LETTER ZEMLYA - {0xA642, 0xA642, prUpper}, // L& CYRILLIC CAPITAL LETTER DZELO - {0xA643, 0xA643, prLower}, // L& CYRILLIC SMALL LETTER DZELO - {0xA644, 0xA644, prUpper}, // L& CYRILLIC CAPITAL LETTER REVERSED DZE - {0xA645, 0xA645, prLower}, // L& CYRILLIC SMALL LETTER REVERSED DZE - {0xA646, 0xA646, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTA - {0xA647, 0xA647, prLower}, // L& CYRILLIC SMALL LETTER IOTA - {0xA648, 0xA648, prUpper}, // L& CYRILLIC CAPITAL LETTER DJERV - {0xA649, 0xA649, prLower}, // L& CYRILLIC SMALL LETTER DJERV - {0xA64A, 0xA64A, prUpper}, // L& CYRILLIC CAPITAL LETTER MONOGRAPH UK - {0xA64B, 0xA64B, prLower}, // L& CYRILLIC SMALL LETTER MONOGRAPH UK - {0xA64C, 0xA64C, prUpper}, // L& CYRILLIC CAPITAL LETTER BROAD OMEGA - {0xA64D, 0xA64D, prLower}, // L& CYRILLIC SMALL LETTER BROAD OMEGA - {0xA64E, 0xA64E, prUpper}, // L& CYRILLIC CAPITAL LETTER NEUTRAL YER - {0xA64F, 0xA64F, prLower}, // L& CYRILLIC SMALL LETTER NEUTRAL YER - {0xA650, 0xA650, prUpper}, // L& CYRILLIC CAPITAL LETTER YERU WITH BACK YER - {0xA651, 0xA651, prLower}, // L& CYRILLIC SMALL LETTER YERU WITH BACK YER - {0xA652, 0xA652, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED YAT - {0xA653, 0xA653, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED YAT - {0xA654, 0xA654, prUpper}, // L& CYRILLIC CAPITAL LETTER REVERSED YU - {0xA655, 0xA655, prLower}, // L& CYRILLIC SMALL LETTER REVERSED YU - {0xA656, 0xA656, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED A - {0xA657, 0xA657, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED A - {0xA658, 0xA658, prUpper}, // L& CYRILLIC CAPITAL LETTER CLOSED LITTLE YUS - {0xA659, 0xA659, prLower}, // L& CYRILLIC SMALL LETTER CLOSED LITTLE YUS - {0xA65A, 0xA65A, prUpper}, // L& CYRILLIC CAPITAL LETTER BLENDED YUS - {0xA65B, 0xA65B, prLower}, // L& CYRILLIC SMALL LETTER BLENDED YUS - {0xA65C, 0xA65C, prUpper}, // L& CYRILLIC CAPITAL LETTER IOTIFIED CLOSED LITTLE YUS - {0xA65D, 0xA65D, prLower}, // L& CYRILLIC SMALL LETTER IOTIFIED CLOSED LITTLE YUS - {0xA65E, 0xA65E, prUpper}, // L& CYRILLIC CAPITAL LETTER YN - {0xA65F, 0xA65F, prLower}, // L& CYRILLIC SMALL LETTER YN - {0xA660, 0xA660, prUpper}, // L& CYRILLIC CAPITAL LETTER REVERSED TSE - {0xA661, 0xA661, prLower}, // L& CYRILLIC SMALL LETTER REVERSED TSE - {0xA662, 0xA662, prUpper}, // L& CYRILLIC CAPITAL LETTER SOFT DE - {0xA663, 0xA663, prLower}, // L& CYRILLIC SMALL LETTER SOFT DE - {0xA664, 0xA664, prUpper}, // L& CYRILLIC CAPITAL LETTER SOFT EL - {0xA665, 0xA665, prLower}, // L& CYRILLIC SMALL LETTER SOFT EL - {0xA666, 0xA666, prUpper}, // L& CYRILLIC CAPITAL LETTER SOFT EM - {0xA667, 0xA667, prLower}, // L& CYRILLIC SMALL LETTER SOFT EM - {0xA668, 0xA668, prUpper}, // L& CYRILLIC CAPITAL LETTER MONOCULAR O - {0xA669, 0xA669, prLower}, // L& CYRILLIC SMALL LETTER MONOCULAR O - {0xA66A, 0xA66A, prUpper}, // L& CYRILLIC CAPITAL LETTER BINOCULAR O - {0xA66B, 0xA66B, prLower}, // L& CYRILLIC SMALL LETTER BINOCULAR O - {0xA66C, 0xA66C, prUpper}, // L& CYRILLIC CAPITAL LETTER DOUBLE MONOCULAR O - {0xA66D, 0xA66D, prLower}, // L& CYRILLIC SMALL LETTER DOUBLE MONOCULAR O - {0xA66E, 0xA66E, prOLetter}, // Lo CYRILLIC LETTER MULTIOCULAR O - {0xA66F, 0xA66F, prExtend}, // Mn COMBINING CYRILLIC VZMET - {0xA670, 0xA672, prExtend}, // Me [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN - {0xA674, 0xA67D, prExtend}, // Mn [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK - {0xA67F, 0xA67F, prOLetter}, // Lm CYRILLIC PAYEROK - {0xA680, 0xA680, prUpper}, // L& CYRILLIC CAPITAL LETTER DWE - {0xA681, 0xA681, prLower}, // L& CYRILLIC SMALL LETTER DWE - {0xA682, 0xA682, prUpper}, // L& CYRILLIC CAPITAL LETTER DZWE - {0xA683, 0xA683, prLower}, // L& CYRILLIC SMALL LETTER DZWE - {0xA684, 0xA684, prUpper}, // L& CYRILLIC CAPITAL LETTER ZHWE - {0xA685, 0xA685, prLower}, // L& CYRILLIC SMALL LETTER ZHWE - {0xA686, 0xA686, prUpper}, // L& CYRILLIC CAPITAL LETTER CCHE - {0xA687, 0xA687, prLower}, // L& CYRILLIC SMALL LETTER CCHE - {0xA688, 0xA688, prUpper}, // L& CYRILLIC CAPITAL LETTER DZZE - {0xA689, 0xA689, prLower}, // L& CYRILLIC SMALL LETTER DZZE - {0xA68A, 0xA68A, prUpper}, // L& CYRILLIC CAPITAL LETTER TE WITH MIDDLE HOOK - {0xA68B, 0xA68B, prLower}, // L& CYRILLIC SMALL LETTER TE WITH MIDDLE HOOK - {0xA68C, 0xA68C, prUpper}, // L& CYRILLIC CAPITAL LETTER TWE - {0xA68D, 0xA68D, prLower}, // L& CYRILLIC SMALL LETTER TWE - {0xA68E, 0xA68E, prUpper}, // L& CYRILLIC CAPITAL LETTER TSWE - {0xA68F, 0xA68F, prLower}, // L& CYRILLIC SMALL LETTER TSWE - {0xA690, 0xA690, prUpper}, // L& CYRILLIC CAPITAL LETTER TSSE - {0xA691, 0xA691, prLower}, // L& CYRILLIC SMALL LETTER TSSE - {0xA692, 0xA692, prUpper}, // L& CYRILLIC CAPITAL LETTER TCHE - {0xA693, 0xA693, prLower}, // L& CYRILLIC SMALL LETTER TCHE - {0xA694, 0xA694, prUpper}, // L& CYRILLIC CAPITAL LETTER HWE - {0xA695, 0xA695, prLower}, // L& CYRILLIC SMALL LETTER HWE - {0xA696, 0xA696, prUpper}, // L& CYRILLIC CAPITAL LETTER SHWE - {0xA697, 0xA697, prLower}, // L& CYRILLIC SMALL LETTER SHWE - {0xA698, 0xA698, prUpper}, // L& CYRILLIC CAPITAL LETTER DOUBLE O - {0xA699, 0xA699, prLower}, // L& CYRILLIC SMALL LETTER DOUBLE O - {0xA69A, 0xA69A, prUpper}, // L& CYRILLIC CAPITAL LETTER CROSSED O - {0xA69B, 0xA69B, prLower}, // L& CYRILLIC SMALL LETTER CROSSED O - {0xA69C, 0xA69D, prLower}, // Lm [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN - {0xA69E, 0xA69F, prExtend}, // Mn [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E - {0xA6A0, 0xA6E5, prOLetter}, // Lo [70] BAMUM LETTER A..BAMUM LETTER KI - {0xA6E6, 0xA6EF, prOLetter}, // Nl [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM - {0xA6F0, 0xA6F1, prExtend}, // Mn [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS - {0xA6F3, 0xA6F3, prSTerm}, // Po BAMUM FULL STOP - {0xA6F7, 0xA6F7, prSTerm}, // Po BAMUM QUESTION MARK - {0xA717, 0xA71F, prOLetter}, // Lm [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK - {0xA722, 0xA722, prUpper}, // L& LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF - {0xA723, 0xA723, prLower}, // L& LATIN SMALL LETTER EGYPTOLOGICAL ALEF - {0xA724, 0xA724, prUpper}, // L& LATIN CAPITAL LETTER EGYPTOLOGICAL AIN - {0xA725, 0xA725, prLower}, // L& LATIN SMALL LETTER EGYPTOLOGICAL AIN - {0xA726, 0xA726, prUpper}, // L& LATIN CAPITAL LETTER HENG - {0xA727, 0xA727, prLower}, // L& LATIN SMALL LETTER HENG - {0xA728, 0xA728, prUpper}, // L& LATIN CAPITAL LETTER TZ - {0xA729, 0xA729, prLower}, // L& LATIN SMALL LETTER TZ - {0xA72A, 0xA72A, prUpper}, // L& LATIN CAPITAL LETTER TRESILLO - {0xA72B, 0xA72B, prLower}, // L& LATIN SMALL LETTER TRESILLO - {0xA72C, 0xA72C, prUpper}, // L& LATIN CAPITAL LETTER CUATRILLO - {0xA72D, 0xA72D, prLower}, // L& LATIN SMALL LETTER CUATRILLO - {0xA72E, 0xA72E, prUpper}, // L& LATIN CAPITAL LETTER CUATRILLO WITH COMMA - {0xA72F, 0xA731, prLower}, // L& [3] LATIN SMALL LETTER CUATRILLO WITH COMMA..LATIN LETTER SMALL CAPITAL S - {0xA732, 0xA732, prUpper}, // L& LATIN CAPITAL LETTER AA - {0xA733, 0xA733, prLower}, // L& LATIN SMALL LETTER AA - {0xA734, 0xA734, prUpper}, // L& LATIN CAPITAL LETTER AO - {0xA735, 0xA735, prLower}, // L& LATIN SMALL LETTER AO - {0xA736, 0xA736, prUpper}, // L& LATIN CAPITAL LETTER AU - {0xA737, 0xA737, prLower}, // L& LATIN SMALL LETTER AU - {0xA738, 0xA738, prUpper}, // L& LATIN CAPITAL LETTER AV - {0xA739, 0xA739, prLower}, // L& LATIN SMALL LETTER AV - {0xA73A, 0xA73A, prUpper}, // L& LATIN CAPITAL LETTER AV WITH HORIZONTAL BAR - {0xA73B, 0xA73B, prLower}, // L& LATIN SMALL LETTER AV WITH HORIZONTAL BAR - {0xA73C, 0xA73C, prUpper}, // L& LATIN CAPITAL LETTER AY - {0xA73D, 0xA73D, prLower}, // L& LATIN SMALL LETTER AY - {0xA73E, 0xA73E, prUpper}, // L& LATIN CAPITAL LETTER REVERSED C WITH DOT - {0xA73F, 0xA73F, prLower}, // L& LATIN SMALL LETTER REVERSED C WITH DOT - {0xA740, 0xA740, prUpper}, // L& LATIN CAPITAL LETTER K WITH STROKE - {0xA741, 0xA741, prLower}, // L& LATIN SMALL LETTER K WITH STROKE - {0xA742, 0xA742, prUpper}, // L& LATIN CAPITAL LETTER K WITH DIAGONAL STROKE - {0xA743, 0xA743, prLower}, // L& LATIN SMALL LETTER K WITH DIAGONAL STROKE - {0xA744, 0xA744, prUpper}, // L& LATIN CAPITAL LETTER K WITH STROKE AND DIAGONAL STROKE - {0xA745, 0xA745, prLower}, // L& LATIN SMALL LETTER K WITH STROKE AND DIAGONAL STROKE - {0xA746, 0xA746, prUpper}, // L& LATIN CAPITAL LETTER BROKEN L - {0xA747, 0xA747, prLower}, // L& LATIN SMALL LETTER BROKEN L - {0xA748, 0xA748, prUpper}, // L& LATIN CAPITAL LETTER L WITH HIGH STROKE - {0xA749, 0xA749, prLower}, // L& LATIN SMALL LETTER L WITH HIGH STROKE - {0xA74A, 0xA74A, prUpper}, // L& LATIN CAPITAL LETTER O WITH LONG STROKE OVERLAY - {0xA74B, 0xA74B, prLower}, // L& LATIN SMALL LETTER O WITH LONG STROKE OVERLAY - {0xA74C, 0xA74C, prUpper}, // L& LATIN CAPITAL LETTER O WITH LOOP - {0xA74D, 0xA74D, prLower}, // L& LATIN SMALL LETTER O WITH LOOP - {0xA74E, 0xA74E, prUpper}, // L& LATIN CAPITAL LETTER OO - {0xA74F, 0xA74F, prLower}, // L& LATIN SMALL LETTER OO - {0xA750, 0xA750, prUpper}, // L& LATIN CAPITAL LETTER P WITH STROKE THROUGH DESCENDER - {0xA751, 0xA751, prLower}, // L& LATIN SMALL LETTER P WITH STROKE THROUGH DESCENDER - {0xA752, 0xA752, prUpper}, // L& LATIN CAPITAL LETTER P WITH FLOURISH - {0xA753, 0xA753, prLower}, // L& LATIN SMALL LETTER P WITH FLOURISH - {0xA754, 0xA754, prUpper}, // L& LATIN CAPITAL LETTER P WITH SQUIRREL TAIL - {0xA755, 0xA755, prLower}, // L& LATIN SMALL LETTER P WITH SQUIRREL TAIL - {0xA756, 0xA756, prUpper}, // L& LATIN CAPITAL LETTER Q WITH STROKE THROUGH DESCENDER - {0xA757, 0xA757, prLower}, // L& LATIN SMALL LETTER Q WITH STROKE THROUGH DESCENDER - {0xA758, 0xA758, prUpper}, // L& LATIN CAPITAL LETTER Q WITH DIAGONAL STROKE - {0xA759, 0xA759, prLower}, // L& LATIN SMALL LETTER Q WITH DIAGONAL STROKE - {0xA75A, 0xA75A, prUpper}, // L& LATIN CAPITAL LETTER R ROTUNDA - {0xA75B, 0xA75B, prLower}, // L& LATIN SMALL LETTER R ROTUNDA - {0xA75C, 0xA75C, prUpper}, // L& LATIN CAPITAL LETTER RUM ROTUNDA - {0xA75D, 0xA75D, prLower}, // L& LATIN SMALL LETTER RUM ROTUNDA - {0xA75E, 0xA75E, prUpper}, // L& LATIN CAPITAL LETTER V WITH DIAGONAL STROKE - {0xA75F, 0xA75F, prLower}, // L& LATIN SMALL LETTER V WITH DIAGONAL STROKE - {0xA760, 0xA760, prUpper}, // L& LATIN CAPITAL LETTER VY - {0xA761, 0xA761, prLower}, // L& LATIN SMALL LETTER VY - {0xA762, 0xA762, prUpper}, // L& LATIN CAPITAL LETTER VISIGOTHIC Z - {0xA763, 0xA763, prLower}, // L& LATIN SMALL LETTER VISIGOTHIC Z - {0xA764, 0xA764, prUpper}, // L& LATIN CAPITAL LETTER THORN WITH STROKE - {0xA765, 0xA765, prLower}, // L& LATIN SMALL LETTER THORN WITH STROKE - {0xA766, 0xA766, prUpper}, // L& LATIN CAPITAL LETTER THORN WITH STROKE THROUGH DESCENDER - {0xA767, 0xA767, prLower}, // L& LATIN SMALL LETTER THORN WITH STROKE THROUGH DESCENDER - {0xA768, 0xA768, prUpper}, // L& LATIN CAPITAL LETTER VEND - {0xA769, 0xA769, prLower}, // L& LATIN SMALL LETTER VEND - {0xA76A, 0xA76A, prUpper}, // L& LATIN CAPITAL LETTER ET - {0xA76B, 0xA76B, prLower}, // L& LATIN SMALL LETTER ET - {0xA76C, 0xA76C, prUpper}, // L& LATIN CAPITAL LETTER IS - {0xA76D, 0xA76D, prLower}, // L& LATIN SMALL LETTER IS - {0xA76E, 0xA76E, prUpper}, // L& LATIN CAPITAL LETTER CON - {0xA76F, 0xA76F, prLower}, // L& LATIN SMALL LETTER CON - {0xA770, 0xA770, prLower}, // Lm MODIFIER LETTER US - {0xA771, 0xA778, prLower}, // L& [8] LATIN SMALL LETTER DUM..LATIN SMALL LETTER UM - {0xA779, 0xA779, prUpper}, // L& LATIN CAPITAL LETTER INSULAR D - {0xA77A, 0xA77A, prLower}, // L& LATIN SMALL LETTER INSULAR D - {0xA77B, 0xA77B, prUpper}, // L& LATIN CAPITAL LETTER INSULAR F - {0xA77C, 0xA77C, prLower}, // L& LATIN SMALL LETTER INSULAR F - {0xA77D, 0xA77E, prUpper}, // L& [2] LATIN CAPITAL LETTER INSULAR G..LATIN CAPITAL LETTER TURNED INSULAR G - {0xA77F, 0xA77F, prLower}, // L& LATIN SMALL LETTER TURNED INSULAR G - {0xA780, 0xA780, prUpper}, // L& LATIN CAPITAL LETTER TURNED L - {0xA781, 0xA781, prLower}, // L& LATIN SMALL LETTER TURNED L - {0xA782, 0xA782, prUpper}, // L& LATIN CAPITAL LETTER INSULAR R - {0xA783, 0xA783, prLower}, // L& LATIN SMALL LETTER INSULAR R - {0xA784, 0xA784, prUpper}, // L& LATIN CAPITAL LETTER INSULAR S - {0xA785, 0xA785, prLower}, // L& LATIN SMALL LETTER INSULAR S - {0xA786, 0xA786, prUpper}, // L& LATIN CAPITAL LETTER INSULAR T - {0xA787, 0xA787, prLower}, // L& LATIN SMALL LETTER INSULAR T - {0xA788, 0xA788, prOLetter}, // Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT - {0xA78B, 0xA78B, prUpper}, // L& LATIN CAPITAL LETTER SALTILLO - {0xA78C, 0xA78C, prLower}, // L& LATIN SMALL LETTER SALTILLO - {0xA78D, 0xA78D, prUpper}, // L& LATIN CAPITAL LETTER TURNED H - {0xA78E, 0xA78E, prLower}, // L& LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT - {0xA78F, 0xA78F, prOLetter}, // Lo LATIN LETTER SINOLOGICAL DOT - {0xA790, 0xA790, prUpper}, // L& LATIN CAPITAL LETTER N WITH DESCENDER - {0xA791, 0xA791, prLower}, // L& LATIN SMALL LETTER N WITH DESCENDER - {0xA792, 0xA792, prUpper}, // L& LATIN CAPITAL LETTER C WITH BAR - {0xA793, 0xA795, prLower}, // L& [3] LATIN SMALL LETTER C WITH BAR..LATIN SMALL LETTER H WITH PALATAL HOOK - {0xA796, 0xA796, prUpper}, // L& LATIN CAPITAL LETTER B WITH FLOURISH - {0xA797, 0xA797, prLower}, // L& LATIN SMALL LETTER B WITH FLOURISH - {0xA798, 0xA798, prUpper}, // L& LATIN CAPITAL LETTER F WITH STROKE - {0xA799, 0xA799, prLower}, // L& LATIN SMALL LETTER F WITH STROKE - {0xA79A, 0xA79A, prUpper}, // L& LATIN CAPITAL LETTER VOLAPUK AE - {0xA79B, 0xA79B, prLower}, // L& LATIN SMALL LETTER VOLAPUK AE - {0xA79C, 0xA79C, prUpper}, // L& LATIN CAPITAL LETTER VOLAPUK OE - {0xA79D, 0xA79D, prLower}, // L& LATIN SMALL LETTER VOLAPUK OE - {0xA79E, 0xA79E, prUpper}, // L& LATIN CAPITAL LETTER VOLAPUK UE - {0xA79F, 0xA79F, prLower}, // L& LATIN SMALL LETTER VOLAPUK UE - {0xA7A0, 0xA7A0, prUpper}, // L& LATIN CAPITAL LETTER G WITH OBLIQUE STROKE - {0xA7A1, 0xA7A1, prLower}, // L& LATIN SMALL LETTER G WITH OBLIQUE STROKE - {0xA7A2, 0xA7A2, prUpper}, // L& LATIN CAPITAL LETTER K WITH OBLIQUE STROKE - {0xA7A3, 0xA7A3, prLower}, // L& LATIN SMALL LETTER K WITH OBLIQUE STROKE - {0xA7A4, 0xA7A4, prUpper}, // L& LATIN CAPITAL LETTER N WITH OBLIQUE STROKE - {0xA7A5, 0xA7A5, prLower}, // L& LATIN SMALL LETTER N WITH OBLIQUE STROKE - {0xA7A6, 0xA7A6, prUpper}, // L& LATIN CAPITAL LETTER R WITH OBLIQUE STROKE - {0xA7A7, 0xA7A7, prLower}, // L& LATIN SMALL LETTER R WITH OBLIQUE STROKE - {0xA7A8, 0xA7A8, prUpper}, // L& LATIN CAPITAL LETTER S WITH OBLIQUE STROKE - {0xA7A9, 0xA7A9, prLower}, // L& LATIN SMALL LETTER S WITH OBLIQUE STROKE - {0xA7AA, 0xA7AE, prUpper}, // L& [5] LATIN CAPITAL LETTER H WITH HOOK..LATIN CAPITAL LETTER SMALL CAPITAL I - {0xA7AF, 0xA7AF, prLower}, // L& LATIN LETTER SMALL CAPITAL Q - {0xA7B0, 0xA7B4, prUpper}, // L& [5] LATIN CAPITAL LETTER TURNED K..LATIN CAPITAL LETTER BETA - {0xA7B5, 0xA7B5, prLower}, // L& LATIN SMALL LETTER BETA - {0xA7B6, 0xA7B6, prUpper}, // L& LATIN CAPITAL LETTER OMEGA - {0xA7B7, 0xA7B7, prLower}, // L& LATIN SMALL LETTER OMEGA - {0xA7B8, 0xA7B8, prUpper}, // L& LATIN CAPITAL LETTER U WITH STROKE - {0xA7B9, 0xA7B9, prLower}, // L& LATIN SMALL LETTER U WITH STROKE - {0xA7BA, 0xA7BA, prUpper}, // L& LATIN CAPITAL LETTER GLOTTAL A - {0xA7BB, 0xA7BB, prLower}, // L& LATIN SMALL LETTER GLOTTAL A - {0xA7BC, 0xA7BC, prUpper}, // L& LATIN CAPITAL LETTER GLOTTAL I - {0xA7BD, 0xA7BD, prLower}, // L& LATIN SMALL LETTER GLOTTAL I - {0xA7BE, 0xA7BE, prUpper}, // L& LATIN CAPITAL LETTER GLOTTAL U - {0xA7BF, 0xA7BF, prLower}, // L& LATIN SMALL LETTER GLOTTAL U - {0xA7C0, 0xA7C0, prUpper}, // L& LATIN CAPITAL LETTER OLD POLISH O - {0xA7C1, 0xA7C1, prLower}, // L& LATIN SMALL LETTER OLD POLISH O - {0xA7C2, 0xA7C2, prUpper}, // L& LATIN CAPITAL LETTER ANGLICANA W - {0xA7C3, 0xA7C3, prLower}, // L& LATIN SMALL LETTER ANGLICANA W - {0xA7C4, 0xA7C7, prUpper}, // L& [4] LATIN CAPITAL LETTER C WITH PALATAL HOOK..LATIN CAPITAL LETTER D WITH SHORT STROKE OVERLAY - {0xA7C8, 0xA7C8, prLower}, // L& LATIN SMALL LETTER D WITH SHORT STROKE OVERLAY - {0xA7C9, 0xA7C9, prUpper}, // L& LATIN CAPITAL LETTER S WITH SHORT STROKE OVERLAY - {0xA7CA, 0xA7CA, prLower}, // L& LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY - {0xA7D0, 0xA7D0, prUpper}, // L& LATIN CAPITAL LETTER CLOSED INSULAR G - {0xA7D1, 0xA7D1, prLower}, // L& LATIN SMALL LETTER CLOSED INSULAR G - {0xA7D3, 0xA7D3, prLower}, // L& LATIN SMALL LETTER DOUBLE THORN - {0xA7D5, 0xA7D5, prLower}, // L& LATIN SMALL LETTER DOUBLE WYNN - {0xA7D6, 0xA7D6, prUpper}, // L& LATIN CAPITAL LETTER MIDDLE SCOTS S - {0xA7D7, 0xA7D7, prLower}, // L& LATIN SMALL LETTER MIDDLE SCOTS S - {0xA7D8, 0xA7D8, prUpper}, // L& LATIN CAPITAL LETTER SIGMOID S - {0xA7D9, 0xA7D9, prLower}, // L& LATIN SMALL LETTER SIGMOID S - {0xA7F2, 0xA7F4, prLower}, // Lm [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q - {0xA7F5, 0xA7F5, prUpper}, // L& LATIN CAPITAL LETTER REVERSED HALF H - {0xA7F6, 0xA7F6, prLower}, // L& LATIN SMALL LETTER REVERSED HALF H - {0xA7F7, 0xA7F7, prOLetter}, // Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I - {0xA7F8, 0xA7F9, prLower}, // Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE - {0xA7FA, 0xA7FA, prLower}, // L& LATIN LETTER SMALL CAPITAL TURNED M - {0xA7FB, 0xA801, prOLetter}, // Lo [7] LATIN EPIGRAPHIC LETTER REVERSED F..SYLOTI NAGRI LETTER I - {0xA802, 0xA802, prExtend}, // Mn SYLOTI NAGRI SIGN DVISVARA - {0xA803, 0xA805, prOLetter}, // Lo [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O - {0xA806, 0xA806, prExtend}, // Mn SYLOTI NAGRI SIGN HASANTA - {0xA807, 0xA80A, prOLetter}, // Lo [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO - {0xA80B, 0xA80B, prExtend}, // Mn SYLOTI NAGRI SIGN ANUSVARA - {0xA80C, 0xA822, prOLetter}, // Lo [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO - {0xA823, 0xA824, prExtend}, // Mc [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I - {0xA825, 0xA826, prExtend}, // Mn [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E - {0xA827, 0xA827, prExtend}, // Mc SYLOTI NAGRI VOWEL SIGN OO - {0xA82C, 0xA82C, prExtend}, // Mn SYLOTI NAGRI SIGN ALTERNATE HASANTA - {0xA840, 0xA873, prOLetter}, // Lo [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU - {0xA876, 0xA877, prSTerm}, // Po [2] PHAGS-PA MARK SHAD..PHAGS-PA MARK DOUBLE SHAD - {0xA880, 0xA881, prExtend}, // Mc [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA - {0xA882, 0xA8B3, prOLetter}, // Lo [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA - {0xA8B4, 0xA8C3, prExtend}, // Mc [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU - {0xA8C4, 0xA8C5, prExtend}, // Mn [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU - {0xA8CE, 0xA8CF, prSTerm}, // Po [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA - {0xA8D0, 0xA8D9, prNumeric}, // Nd [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE - {0xA8E0, 0xA8F1, prExtend}, // Mn [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA - {0xA8F2, 0xA8F7, prOLetter}, // Lo [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA - {0xA8FB, 0xA8FB, prOLetter}, // Lo DEVANAGARI HEADSTROKE - {0xA8FD, 0xA8FE, prOLetter}, // Lo [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY - {0xA8FF, 0xA8FF, prExtend}, // Mn DEVANAGARI VOWEL SIGN AY - {0xA900, 0xA909, prNumeric}, // Nd [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE - {0xA90A, 0xA925, prOLetter}, // Lo [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO - {0xA926, 0xA92D, prExtend}, // Mn [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU - {0xA92F, 0xA92F, prSTerm}, // Po KAYAH LI SIGN SHYA - {0xA930, 0xA946, prOLetter}, // Lo [23] REJANG LETTER KA..REJANG LETTER A - {0xA947, 0xA951, prExtend}, // Mn [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R - {0xA952, 0xA953, prExtend}, // Mc [2] REJANG CONSONANT SIGN H..REJANG VIRAMA - {0xA960, 0xA97C, prOLetter}, // Lo [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH - {0xA980, 0xA982, prExtend}, // Mn [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR - {0xA983, 0xA983, prExtend}, // Mc JAVANESE SIGN WIGNYAN - {0xA984, 0xA9B2, prOLetter}, // Lo [47] JAVANESE LETTER A..JAVANESE LETTER HA - {0xA9B3, 0xA9B3, prExtend}, // Mn JAVANESE SIGN CECAK TELU - {0xA9B4, 0xA9B5, prExtend}, // Mc [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG - {0xA9B6, 0xA9B9, prExtend}, // Mn [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT - {0xA9BA, 0xA9BB, prExtend}, // Mc [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE - {0xA9BC, 0xA9BD, prExtend}, // Mn [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET - {0xA9BE, 0xA9C0, prExtend}, // Mc [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON - {0xA9C8, 0xA9C9, prSTerm}, // Po [2] JAVANESE PADA LINGSA..JAVANESE PADA LUNGSI - {0xA9CF, 0xA9CF, prOLetter}, // Lm JAVANESE PANGRANGKEP - {0xA9D0, 0xA9D9, prNumeric}, // Nd [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE - {0xA9E0, 0xA9E4, prOLetter}, // Lo [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA - {0xA9E5, 0xA9E5, prExtend}, // Mn MYANMAR SIGN SHAN SAW - {0xA9E6, 0xA9E6, prOLetter}, // Lm MYANMAR MODIFIER LETTER SHAN REDUPLICATION - {0xA9E7, 0xA9EF, prOLetter}, // Lo [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA - {0xA9F0, 0xA9F9, prNumeric}, // Nd [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE - {0xA9FA, 0xA9FE, prOLetter}, // Lo [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA - {0xAA00, 0xAA28, prOLetter}, // Lo [41] CHAM LETTER A..CHAM LETTER HA - {0xAA29, 0xAA2E, prExtend}, // Mn [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE - {0xAA2F, 0xAA30, prExtend}, // Mc [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI - {0xAA31, 0xAA32, prExtend}, // Mn [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE - {0xAA33, 0xAA34, prExtend}, // Mc [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA - {0xAA35, 0xAA36, prExtend}, // Mn [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA - {0xAA40, 0xAA42, prOLetter}, // Lo [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG - {0xAA43, 0xAA43, prExtend}, // Mn CHAM CONSONANT SIGN FINAL NG - {0xAA44, 0xAA4B, prOLetter}, // Lo [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS - {0xAA4C, 0xAA4C, prExtend}, // Mn CHAM CONSONANT SIGN FINAL M - {0xAA4D, 0xAA4D, prExtend}, // Mc CHAM CONSONANT SIGN FINAL H - {0xAA50, 0xAA59, prNumeric}, // Nd [10] CHAM DIGIT ZERO..CHAM DIGIT NINE - {0xAA5D, 0xAA5F, prSTerm}, // Po [3] CHAM PUNCTUATION DANDA..CHAM PUNCTUATION TRIPLE DANDA - {0xAA60, 0xAA6F, prOLetter}, // Lo [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA - {0xAA70, 0xAA70, prOLetter}, // Lm MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION - {0xAA71, 0xAA76, prOLetter}, // Lo [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM - {0xAA7A, 0xAA7A, prOLetter}, // Lo MYANMAR LETTER AITON RA - {0xAA7B, 0xAA7B, prExtend}, // Mc MYANMAR SIGN PAO KAREN TONE - {0xAA7C, 0xAA7C, prExtend}, // Mn MYANMAR SIGN TAI LAING TONE-2 - {0xAA7D, 0xAA7D, prExtend}, // Mc MYANMAR SIGN TAI LAING TONE-5 - {0xAA7E, 0xAAAF, prOLetter}, // Lo [50] MYANMAR LETTER SHWE PALAUNG CHA..TAI VIET LETTER HIGH O - {0xAAB0, 0xAAB0, prExtend}, // Mn TAI VIET MAI KANG - {0xAAB1, 0xAAB1, prOLetter}, // Lo TAI VIET VOWEL AA - {0xAAB2, 0xAAB4, prExtend}, // Mn [3] TAI VIET VOWEL I..TAI VIET VOWEL U - {0xAAB5, 0xAAB6, prOLetter}, // Lo [2] TAI VIET VOWEL E..TAI VIET VOWEL O - {0xAAB7, 0xAAB8, prExtend}, // Mn [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA - {0xAAB9, 0xAABD, prOLetter}, // Lo [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN - {0xAABE, 0xAABF, prExtend}, // Mn [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK - {0xAAC0, 0xAAC0, prOLetter}, // Lo TAI VIET TONE MAI NUENG - {0xAAC1, 0xAAC1, prExtend}, // Mn TAI VIET TONE MAI THO - {0xAAC2, 0xAAC2, prOLetter}, // Lo TAI VIET TONE MAI SONG - {0xAADB, 0xAADC, prOLetter}, // Lo [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG - {0xAADD, 0xAADD, prOLetter}, // Lm TAI VIET SYMBOL SAM - {0xAAE0, 0xAAEA, prOLetter}, // Lo [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA - {0xAAEB, 0xAAEB, prExtend}, // Mc MEETEI MAYEK VOWEL SIGN II - {0xAAEC, 0xAAED, prExtend}, // Mn [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI - {0xAAEE, 0xAAEF, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU - {0xAAF0, 0xAAF1, prSTerm}, // Po [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM - {0xAAF2, 0xAAF2, prOLetter}, // Lo MEETEI MAYEK ANJI - {0xAAF3, 0xAAF4, prOLetter}, // Lm [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK - {0xAAF5, 0xAAF5, prExtend}, // Mc MEETEI MAYEK VOWEL SIGN VISARGA - {0xAAF6, 0xAAF6, prExtend}, // Mn MEETEI MAYEK VIRAMA - {0xAB01, 0xAB06, prOLetter}, // Lo [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO - {0xAB09, 0xAB0E, prOLetter}, // Lo [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO - {0xAB11, 0xAB16, prOLetter}, // Lo [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO - {0xAB20, 0xAB26, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO - {0xAB28, 0xAB2E, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO - {0xAB30, 0xAB5A, prLower}, // L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG - {0xAB5C, 0xAB5F, prLower}, // Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK - {0xAB60, 0xAB68, prLower}, // L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE - {0xAB69, 0xAB69, prLower}, // Lm MODIFIER LETTER SMALL TURNED W - {0xAB70, 0xABBF, prLower}, // L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA - {0xABC0, 0xABE2, prOLetter}, // Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM - {0xABE3, 0xABE4, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP - {0xABE5, 0xABE5, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN ANAP - {0xABE6, 0xABE7, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP - {0xABE8, 0xABE8, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN UNAP - {0xABE9, 0xABEA, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG - {0xABEB, 0xABEB, prSTerm}, // Po MEETEI MAYEK CHEIKHEI - {0xABEC, 0xABEC, prExtend}, // Mc MEETEI MAYEK LUM IYEK - {0xABED, 0xABED, prExtend}, // Mn MEETEI MAYEK APUN IYEK - {0xABF0, 0xABF9, prNumeric}, // Nd [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE - {0xAC00, 0xD7A3, prOLetter}, // Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH - {0xD7B0, 0xD7C6, prOLetter}, // Lo [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E - {0xD7CB, 0xD7FB, prOLetter}, // Lo [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH - {0xF900, 0xFA6D, prOLetter}, // Lo [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D - {0xFA70, 0xFAD9, prOLetter}, // Lo [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9 - {0xFB00, 0xFB06, prLower}, // L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST - {0xFB13, 0xFB17, prLower}, // L& [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH - {0xFB1D, 0xFB1D, prOLetter}, // Lo HEBREW LETTER YOD WITH HIRIQ - {0xFB1E, 0xFB1E, prExtend}, // Mn HEBREW POINT JUDEO-SPANISH VARIKA - {0xFB1F, 0xFB28, prOLetter}, // Lo [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV - {0xFB2A, 0xFB36, prOLetter}, // Lo [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH - {0xFB38, 0xFB3C, prOLetter}, // Lo [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH - {0xFB3E, 0xFB3E, prOLetter}, // Lo HEBREW LETTER MEM WITH DAGESH - {0xFB40, 0xFB41, prOLetter}, // Lo [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH - {0xFB43, 0xFB44, prOLetter}, // Lo [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH - {0xFB46, 0xFBB1, prOLetter}, // Lo [108] HEBREW LETTER TSADI WITH DAGESH..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM - {0xFBD3, 0xFD3D, prOLetter}, // Lo [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM - {0xFD3E, 0xFD3E, prClose}, // Pe ORNATE LEFT PARENTHESIS - {0xFD3F, 0xFD3F, prClose}, // Ps ORNATE RIGHT PARENTHESIS - {0xFD50, 0xFD8F, prOLetter}, // Lo [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM - {0xFD92, 0xFDC7, prOLetter}, // Lo [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM - {0xFDF0, 0xFDFB, prOLetter}, // Lo [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU - {0xFE00, 0xFE0F, prExtend}, // Mn [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16 - {0xFE10, 0xFE11, prSContinue}, // Po [2] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA - {0xFE13, 0xFE13, prSContinue}, // Po PRESENTATION FORM FOR VERTICAL COLON - {0xFE17, 0xFE17, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET - {0xFE18, 0xFE18, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET - {0xFE20, 0xFE2F, prExtend}, // Mn [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF - {0xFE31, 0xFE32, prSContinue}, // Pd [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH - {0xFE35, 0xFE35, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS - {0xFE36, 0xFE36, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS - {0xFE37, 0xFE37, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET - {0xFE38, 0xFE38, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET - {0xFE39, 0xFE39, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET - {0xFE3A, 0xFE3A, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET - {0xFE3B, 0xFE3B, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET - {0xFE3C, 0xFE3C, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET - {0xFE3D, 0xFE3D, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET - {0xFE3E, 0xFE3E, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET - {0xFE3F, 0xFE3F, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET - {0xFE40, 0xFE40, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET - {0xFE41, 0xFE41, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET - {0xFE42, 0xFE42, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET - {0xFE43, 0xFE43, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET - {0xFE44, 0xFE44, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET - {0xFE47, 0xFE47, prClose}, // Ps PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET - {0xFE48, 0xFE48, prClose}, // Pe PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET - {0xFE50, 0xFE51, prSContinue}, // Po [2] SMALL COMMA..SMALL IDEOGRAPHIC COMMA - {0xFE52, 0xFE52, prATerm}, // Po SMALL FULL STOP - {0xFE55, 0xFE55, prSContinue}, // Po SMALL COLON - {0xFE56, 0xFE57, prSTerm}, // Po [2] SMALL QUESTION MARK..SMALL EXCLAMATION MARK - {0xFE58, 0xFE58, prSContinue}, // Pd SMALL EM DASH - {0xFE59, 0xFE59, prClose}, // Ps SMALL LEFT PARENTHESIS - {0xFE5A, 0xFE5A, prClose}, // Pe SMALL RIGHT PARENTHESIS - {0xFE5B, 0xFE5B, prClose}, // Ps SMALL LEFT CURLY BRACKET - {0xFE5C, 0xFE5C, prClose}, // Pe SMALL RIGHT CURLY BRACKET - {0xFE5D, 0xFE5D, prClose}, // Ps SMALL LEFT TORTOISE SHELL BRACKET - {0xFE5E, 0xFE5E, prClose}, // Pe SMALL RIGHT TORTOISE SHELL BRACKET - {0xFE63, 0xFE63, prSContinue}, // Pd SMALL HYPHEN-MINUS - {0xFE70, 0xFE74, prOLetter}, // Lo [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM - {0xFE76, 0xFEFC, prOLetter}, // Lo [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM - {0xFEFF, 0xFEFF, prFormat}, // Cf ZERO WIDTH NO-BREAK SPACE - {0xFF01, 0xFF01, prSTerm}, // Po FULLWIDTH EXCLAMATION MARK - {0xFF08, 0xFF08, prClose}, // Ps FULLWIDTH LEFT PARENTHESIS - {0xFF09, 0xFF09, prClose}, // Pe FULLWIDTH RIGHT PARENTHESIS - {0xFF0C, 0xFF0C, prSContinue}, // Po FULLWIDTH COMMA - {0xFF0D, 0xFF0D, prSContinue}, // Pd FULLWIDTH HYPHEN-MINUS - {0xFF0E, 0xFF0E, prATerm}, // Po FULLWIDTH FULL STOP - {0xFF10, 0xFF19, prNumeric}, // Nd [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE - {0xFF1A, 0xFF1A, prSContinue}, // Po FULLWIDTH COLON - {0xFF1F, 0xFF1F, prSTerm}, // Po FULLWIDTH QUESTION MARK - {0xFF21, 0xFF3A, prUpper}, // L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z - {0xFF3B, 0xFF3B, prClose}, // Ps FULLWIDTH LEFT SQUARE BRACKET - {0xFF3D, 0xFF3D, prClose}, // Pe FULLWIDTH RIGHT SQUARE BRACKET - {0xFF41, 0xFF5A, prLower}, // L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z - {0xFF5B, 0xFF5B, prClose}, // Ps FULLWIDTH LEFT CURLY BRACKET - {0xFF5D, 0xFF5D, prClose}, // Pe FULLWIDTH RIGHT CURLY BRACKET - {0xFF5F, 0xFF5F, prClose}, // Ps FULLWIDTH LEFT WHITE PARENTHESIS - {0xFF60, 0xFF60, prClose}, // Pe FULLWIDTH RIGHT WHITE PARENTHESIS - {0xFF61, 0xFF61, prSTerm}, // Po HALFWIDTH IDEOGRAPHIC FULL STOP - {0xFF62, 0xFF62, prClose}, // Ps HALFWIDTH LEFT CORNER BRACKET - {0xFF63, 0xFF63, prClose}, // Pe HALFWIDTH RIGHT CORNER BRACKET - {0xFF64, 0xFF64, prSContinue}, // Po HALFWIDTH IDEOGRAPHIC COMMA - {0xFF66, 0xFF6F, prOLetter}, // Lo [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU - {0xFF70, 0xFF70, prOLetter}, // Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK - {0xFF71, 0xFF9D, prOLetter}, // Lo [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N - {0xFF9E, 0xFF9F, prExtend}, // Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK - {0xFFA0, 0xFFBE, prOLetter}, // Lo [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH - {0xFFC2, 0xFFC7, prOLetter}, // Lo [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E - {0xFFCA, 0xFFCF, prOLetter}, // Lo [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE - {0xFFD2, 0xFFD7, prOLetter}, // Lo [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU - {0xFFDA, 0xFFDC, prOLetter}, // Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I - {0xFFF9, 0xFFFB, prFormat}, // Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR - {0x10000, 0x1000B, prOLetter}, // Lo [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE - {0x1000D, 0x10026, prOLetter}, // Lo [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO - {0x10028, 0x1003A, prOLetter}, // Lo [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO - {0x1003C, 0x1003D, prOLetter}, // Lo [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE - {0x1003F, 0x1004D, prOLetter}, // Lo [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO - {0x10050, 0x1005D, prOLetter}, // Lo [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089 - {0x10080, 0x100FA, prOLetter}, // Lo [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305 - {0x10140, 0x10174, prOLetter}, // Nl [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS - {0x101FD, 0x101FD, prExtend}, // Mn PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE - {0x10280, 0x1029C, prOLetter}, // Lo [29] LYCIAN LETTER A..LYCIAN LETTER X - {0x102A0, 0x102D0, prOLetter}, // Lo [49] CARIAN LETTER A..CARIAN LETTER UUU3 - {0x102E0, 0x102E0, prExtend}, // Mn COPTIC EPACT THOUSANDS MARK - {0x10300, 0x1031F, prOLetter}, // Lo [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS - {0x1032D, 0x10340, prOLetter}, // Lo [20] OLD ITALIC LETTER YE..GOTHIC LETTER PAIRTHRA - {0x10341, 0x10341, prOLetter}, // Nl GOTHIC LETTER NINETY - {0x10342, 0x10349, prOLetter}, // Lo [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL - {0x1034A, 0x1034A, prOLetter}, // Nl GOTHIC LETTER NINE HUNDRED - {0x10350, 0x10375, prOLetter}, // Lo [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA - {0x10376, 0x1037A, prExtend}, // Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII - {0x10380, 0x1039D, prOLetter}, // Lo [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU - {0x103A0, 0x103C3, prOLetter}, // Lo [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA - {0x103C8, 0x103CF, prOLetter}, // Lo [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH - {0x103D1, 0x103D5, prOLetter}, // Nl [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED - {0x10400, 0x10427, prUpper}, // L& [40] DESERET CAPITAL LETTER LONG I..DESERET CAPITAL LETTER EW - {0x10428, 0x1044F, prLower}, // L& [40] DESERET SMALL LETTER LONG I..DESERET SMALL LETTER EW - {0x10450, 0x1049D, prOLetter}, // Lo [78] SHAVIAN LETTER PEEP..OSMANYA LETTER OO - {0x104A0, 0x104A9, prNumeric}, // Nd [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE - {0x104B0, 0x104D3, prUpper}, // L& [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA - {0x104D8, 0x104FB, prLower}, // L& [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA - {0x10500, 0x10527, prOLetter}, // Lo [40] ELBASAN LETTER A..ELBASAN LETTER KHE - {0x10530, 0x10563, prOLetter}, // Lo [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW - {0x10570, 0x1057A, prUpper}, // L& [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA - {0x1057C, 0x1058A, prUpper}, // L& [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE - {0x1058C, 0x10592, prUpper}, // L& [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE - {0x10594, 0x10595, prUpper}, // L& [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE - {0x10597, 0x105A1, prLower}, // L& [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA - {0x105A3, 0x105B1, prLower}, // L& [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE - {0x105B3, 0x105B9, prLower}, // L& [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE - {0x105BB, 0x105BC, prLower}, // L& [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE - {0x10600, 0x10736, prOLetter}, // Lo [311] LINEAR A SIGN AB001..LINEAR A SIGN A664 - {0x10740, 0x10755, prOLetter}, // Lo [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE - {0x10760, 0x10767, prOLetter}, // Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 - {0x10780, 0x10780, prLower}, // Lm MODIFIER LETTER SMALL CAPITAL AA - {0x10781, 0x10782, prOLetter}, // Lm [2] MODIFIER LETTER SUPERSCRIPT TRIANGULAR COLON..MODIFIER LETTER SUPERSCRIPT HALF TRIANGULAR COLON - {0x10783, 0x10785, prLower}, // Lm [3] MODIFIER LETTER SMALL AE..MODIFIER LETTER SMALL B WITH HOOK - {0x10787, 0x107B0, prLower}, // Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK - {0x107B2, 0x107BA, prLower}, // Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL - {0x10800, 0x10805, prOLetter}, // Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA - {0x10808, 0x10808, prOLetter}, // Lo CYPRIOT SYLLABLE JO - {0x1080A, 0x10835, prOLetter}, // Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO - {0x10837, 0x10838, prOLetter}, // Lo [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE - {0x1083C, 0x1083C, prOLetter}, // Lo CYPRIOT SYLLABLE ZA - {0x1083F, 0x10855, prOLetter}, // Lo [23] CYPRIOT SYLLABLE ZO..IMPERIAL ARAMAIC LETTER TAW - {0x10860, 0x10876, prOLetter}, // Lo [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW - {0x10880, 0x1089E, prOLetter}, // Lo [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW - {0x108E0, 0x108F2, prOLetter}, // Lo [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH - {0x108F4, 0x108F5, prOLetter}, // Lo [2] HATRAN LETTER SHIN..HATRAN LETTER TAW - {0x10900, 0x10915, prOLetter}, // Lo [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU - {0x10920, 0x10939, prOLetter}, // Lo [26] LYDIAN LETTER A..LYDIAN LETTER C - {0x10980, 0x109B7, prOLetter}, // Lo [56] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC CURSIVE LETTER DA - {0x109BE, 0x109BF, prOLetter}, // Lo [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN - {0x10A00, 0x10A00, prOLetter}, // Lo KHAROSHTHI LETTER A - {0x10A01, 0x10A03, prExtend}, // Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R - {0x10A05, 0x10A06, prExtend}, // Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O - {0x10A0C, 0x10A0F, prExtend}, // Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA - {0x10A10, 0x10A13, prOLetter}, // Lo [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA - {0x10A15, 0x10A17, prOLetter}, // Lo [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA - {0x10A19, 0x10A35, prOLetter}, // Lo [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA - {0x10A38, 0x10A3A, prExtend}, // Mn [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW - {0x10A3F, 0x10A3F, prExtend}, // Mn KHAROSHTHI VIRAMA - {0x10A56, 0x10A57, prSTerm}, // Po [2] KHAROSHTHI PUNCTUATION DANDA..KHAROSHTHI PUNCTUATION DOUBLE DANDA - {0x10A60, 0x10A7C, prOLetter}, // Lo [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH - {0x10A80, 0x10A9C, prOLetter}, // Lo [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH - {0x10AC0, 0x10AC7, prOLetter}, // Lo [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW - {0x10AC9, 0x10AE4, prOLetter}, // Lo [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW - {0x10AE5, 0x10AE6, prExtend}, // Mn [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW - {0x10B00, 0x10B35, prOLetter}, // Lo [54] AVESTAN LETTER A..AVESTAN LETTER HE - {0x10B40, 0x10B55, prOLetter}, // Lo [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW - {0x10B60, 0x10B72, prOLetter}, // Lo [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW - {0x10B80, 0x10B91, prOLetter}, // Lo [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW - {0x10C00, 0x10C48, prOLetter}, // Lo [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH - {0x10C80, 0x10CB2, prUpper}, // L& [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US - {0x10CC0, 0x10CF2, prLower}, // L& [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US - {0x10D00, 0x10D23, prOLetter}, // Lo [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA - {0x10D24, 0x10D27, prExtend}, // Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI - {0x10D30, 0x10D39, prNumeric}, // Nd [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE - {0x10E80, 0x10EA9, prOLetter}, // Lo [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET - {0x10EAB, 0x10EAC, prExtend}, // Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK - {0x10EB0, 0x10EB1, prOLetter}, // Lo [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE - {0x10EFD, 0x10EFF, prExtend}, // Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA - {0x10F00, 0x10F1C, prOLetter}, // Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL - {0x10F27, 0x10F27, prOLetter}, // Lo OLD SOGDIAN LIGATURE AYIN-DALETH - {0x10F30, 0x10F45, prOLetter}, // Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN - {0x10F46, 0x10F50, prExtend}, // Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW - {0x10F55, 0x10F59, prSTerm}, // Po [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT - {0x10F70, 0x10F81, prOLetter}, // Lo [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH - {0x10F82, 0x10F85, prExtend}, // Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW - {0x10F86, 0x10F89, prSTerm}, // Po [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS - {0x10FB0, 0x10FC4, prOLetter}, // Lo [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW - {0x10FE0, 0x10FF6, prOLetter}, // Lo [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH - {0x11000, 0x11000, prExtend}, // Mc BRAHMI SIGN CANDRABINDU - {0x11001, 0x11001, prExtend}, // Mn BRAHMI SIGN ANUSVARA - {0x11002, 0x11002, prExtend}, // Mc BRAHMI SIGN VISARGA - {0x11003, 0x11037, prOLetter}, // Lo [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA - {0x11038, 0x11046, prExtend}, // Mn [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA - {0x11047, 0x11048, prSTerm}, // Po [2] BRAHMI DANDA..BRAHMI DOUBLE DANDA - {0x11066, 0x1106F, prNumeric}, // Nd [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE - {0x11070, 0x11070, prExtend}, // Mn BRAHMI SIGN OLD TAMIL VIRAMA - {0x11071, 0x11072, prOLetter}, // Lo [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O - {0x11073, 0x11074, prExtend}, // Mn [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O - {0x11075, 0x11075, prOLetter}, // Lo BRAHMI LETTER OLD TAMIL LLA - {0x1107F, 0x11081, prExtend}, // Mn [3] BRAHMI NUMBER JOINER..KAITHI SIGN ANUSVARA - {0x11082, 0x11082, prExtend}, // Mc KAITHI SIGN VISARGA - {0x11083, 0x110AF, prOLetter}, // Lo [45] KAITHI LETTER A..KAITHI LETTER HA - {0x110B0, 0x110B2, prExtend}, // Mc [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II - {0x110B3, 0x110B6, prExtend}, // Mn [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI - {0x110B7, 0x110B8, prExtend}, // Mc [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU - {0x110B9, 0x110BA, prExtend}, // Mn [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA - {0x110BD, 0x110BD, prFormat}, // Cf KAITHI NUMBER SIGN - {0x110BE, 0x110C1, prSTerm}, // Po [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA - {0x110C2, 0x110C2, prExtend}, // Mn KAITHI VOWEL SIGN VOCALIC R - {0x110CD, 0x110CD, prFormat}, // Cf KAITHI NUMBER SIGN ABOVE - {0x110D0, 0x110E8, prOLetter}, // Lo [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE - {0x110F0, 0x110F9, prNumeric}, // Nd [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE - {0x11100, 0x11102, prExtend}, // Mn [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA - {0x11103, 0x11126, prOLetter}, // Lo [36] CHAKMA LETTER AA..CHAKMA LETTER HAA - {0x11127, 0x1112B, prExtend}, // Mn [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU - {0x1112C, 0x1112C, prExtend}, // Mc CHAKMA VOWEL SIGN E - {0x1112D, 0x11134, prExtend}, // Mn [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA - {0x11136, 0x1113F, prNumeric}, // Nd [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE - {0x11141, 0x11143, prSTerm}, // Po [3] CHAKMA DANDA..CHAKMA QUESTION MARK - {0x11144, 0x11144, prOLetter}, // Lo CHAKMA LETTER LHAA - {0x11145, 0x11146, prExtend}, // Mc [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI - {0x11147, 0x11147, prOLetter}, // Lo CHAKMA LETTER VAA - {0x11150, 0x11172, prOLetter}, // Lo [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA - {0x11173, 0x11173, prExtend}, // Mn MAHAJANI SIGN NUKTA - {0x11176, 0x11176, prOLetter}, // Lo MAHAJANI LIGATURE SHRI - {0x11180, 0x11181, prExtend}, // Mn [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA - {0x11182, 0x11182, prExtend}, // Mc SHARADA SIGN VISARGA - {0x11183, 0x111B2, prOLetter}, // Lo [48] SHARADA LETTER A..SHARADA LETTER HA - {0x111B3, 0x111B5, prExtend}, // Mc [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II - {0x111B6, 0x111BE, prExtend}, // Mn [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O - {0x111BF, 0x111C0, prExtend}, // Mc [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA - {0x111C1, 0x111C4, prOLetter}, // Lo [4] SHARADA SIGN AVAGRAHA..SHARADA OM - {0x111C5, 0x111C6, prSTerm}, // Po [2] SHARADA DANDA..SHARADA DOUBLE DANDA - {0x111C9, 0x111CC, prExtend}, // Mn [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK - {0x111CD, 0x111CD, prSTerm}, // Po SHARADA SUTRA MARK - {0x111CE, 0x111CE, prExtend}, // Mc SHARADA VOWEL SIGN PRISHTHAMATRA E - {0x111CF, 0x111CF, prExtend}, // Mn SHARADA SIGN INVERTED CANDRABINDU - {0x111D0, 0x111D9, prNumeric}, // Nd [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE - {0x111DA, 0x111DA, prOLetter}, // Lo SHARADA EKAM - {0x111DC, 0x111DC, prOLetter}, // Lo SHARADA HEADSTROKE - {0x111DE, 0x111DF, prSTerm}, // Po [2] SHARADA SECTION MARK-1..SHARADA SECTION MARK-2 - {0x11200, 0x11211, prOLetter}, // Lo [18] KHOJKI LETTER A..KHOJKI LETTER JJA - {0x11213, 0x1122B, prOLetter}, // Lo [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA - {0x1122C, 0x1122E, prExtend}, // Mc [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II - {0x1122F, 0x11231, prExtend}, // Mn [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI - {0x11232, 0x11233, prExtend}, // Mc [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU - {0x11234, 0x11234, prExtend}, // Mn KHOJKI SIGN ANUSVARA - {0x11235, 0x11235, prExtend}, // Mc KHOJKI SIGN VIRAMA - {0x11236, 0x11237, prExtend}, // Mn [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA - {0x11238, 0x11239, prSTerm}, // Po [2] KHOJKI DANDA..KHOJKI DOUBLE DANDA - {0x1123B, 0x1123C, prSTerm}, // Po [2] KHOJKI SECTION MARK..KHOJKI DOUBLE SECTION MARK - {0x1123E, 0x1123E, prExtend}, // Mn KHOJKI SIGN SUKUN - {0x1123F, 0x11240, prOLetter}, // Lo [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I - {0x11241, 0x11241, prExtend}, // Mn KHOJKI VOWEL SIGN VOCALIC R - {0x11280, 0x11286, prOLetter}, // Lo [7] MULTANI LETTER A..MULTANI LETTER GA - {0x11288, 0x11288, prOLetter}, // Lo MULTANI LETTER GHA - {0x1128A, 0x1128D, prOLetter}, // Lo [4] MULTANI LETTER CA..MULTANI LETTER JJA - {0x1128F, 0x1129D, prOLetter}, // Lo [15] MULTANI LETTER NYA..MULTANI LETTER BA - {0x1129F, 0x112A8, prOLetter}, // Lo [10] MULTANI LETTER BHA..MULTANI LETTER RHA - {0x112A9, 0x112A9, prSTerm}, // Po MULTANI SECTION MARK - {0x112B0, 0x112DE, prOLetter}, // Lo [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA - {0x112DF, 0x112DF, prExtend}, // Mn KHUDAWADI SIGN ANUSVARA - {0x112E0, 0x112E2, prExtend}, // Mc [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II - {0x112E3, 0x112EA, prExtend}, // Mn [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA - {0x112F0, 0x112F9, prNumeric}, // Nd [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE - {0x11300, 0x11301, prExtend}, // Mn [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU - {0x11302, 0x11303, prExtend}, // Mc [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA - {0x11305, 0x1130C, prOLetter}, // Lo [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L - {0x1130F, 0x11310, prOLetter}, // Lo [2] GRANTHA LETTER EE..GRANTHA LETTER AI - {0x11313, 0x11328, prOLetter}, // Lo [22] GRANTHA LETTER OO..GRANTHA LETTER NA - {0x1132A, 0x11330, prOLetter}, // Lo [7] GRANTHA LETTER PA..GRANTHA LETTER RA - {0x11332, 0x11333, prOLetter}, // Lo [2] GRANTHA LETTER LA..GRANTHA LETTER LLA - {0x11335, 0x11339, prOLetter}, // Lo [5] GRANTHA LETTER VA..GRANTHA LETTER HA - {0x1133B, 0x1133C, prExtend}, // Mn [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA - {0x1133D, 0x1133D, prOLetter}, // Lo GRANTHA SIGN AVAGRAHA - {0x1133E, 0x1133F, prExtend}, // Mc [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I - {0x11340, 0x11340, prExtend}, // Mn GRANTHA VOWEL SIGN II - {0x11341, 0x11344, prExtend}, // Mc [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR - {0x11347, 0x11348, prExtend}, // Mc [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI - {0x1134B, 0x1134D, prExtend}, // Mc [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA - {0x11350, 0x11350, prOLetter}, // Lo GRANTHA OM - {0x11357, 0x11357, prExtend}, // Mc GRANTHA AU LENGTH MARK - {0x1135D, 0x11361, prOLetter}, // Lo [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL - {0x11362, 0x11363, prExtend}, // Mc [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL - {0x11366, 0x1136C, prExtend}, // Mn [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX - {0x11370, 0x11374, prExtend}, // Mn [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA - {0x11400, 0x11434, prOLetter}, // Lo [53] NEWA LETTER A..NEWA LETTER HA - {0x11435, 0x11437, prExtend}, // Mc [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II - {0x11438, 0x1143F, prExtend}, // Mn [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI - {0x11440, 0x11441, prExtend}, // Mc [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU - {0x11442, 0x11444, prExtend}, // Mn [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA - {0x11445, 0x11445, prExtend}, // Mc NEWA SIGN VISARGA - {0x11446, 0x11446, prExtend}, // Mn NEWA SIGN NUKTA - {0x11447, 0x1144A, prOLetter}, // Lo [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI - {0x1144B, 0x1144C, prSTerm}, // Po [2] NEWA DANDA..NEWA DOUBLE DANDA - {0x11450, 0x11459, prNumeric}, // Nd [10] NEWA DIGIT ZERO..NEWA DIGIT NINE - {0x1145E, 0x1145E, prExtend}, // Mn NEWA SANDHI MARK - {0x1145F, 0x11461, prOLetter}, // Lo [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA - {0x11480, 0x114AF, prOLetter}, // Lo [48] TIRHUTA ANJI..TIRHUTA LETTER HA - {0x114B0, 0x114B2, prExtend}, // Mc [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II - {0x114B3, 0x114B8, prExtend}, // Mn [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL - {0x114B9, 0x114B9, prExtend}, // Mc TIRHUTA VOWEL SIGN E - {0x114BA, 0x114BA, prExtend}, // Mn TIRHUTA VOWEL SIGN SHORT E - {0x114BB, 0x114BE, prExtend}, // Mc [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU - {0x114BF, 0x114C0, prExtend}, // Mn [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA - {0x114C1, 0x114C1, prExtend}, // Mc TIRHUTA SIGN VISARGA - {0x114C2, 0x114C3, prExtend}, // Mn [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA - {0x114C4, 0x114C5, prOLetter}, // Lo [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG - {0x114C7, 0x114C7, prOLetter}, // Lo TIRHUTA OM - {0x114D0, 0x114D9, prNumeric}, // Nd [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE - {0x11580, 0x115AE, prOLetter}, // Lo [47] SIDDHAM LETTER A..SIDDHAM LETTER HA - {0x115AF, 0x115B1, prExtend}, // Mc [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II - {0x115B2, 0x115B5, prExtend}, // Mn [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR - {0x115B8, 0x115BB, prExtend}, // Mc [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU - {0x115BC, 0x115BD, prExtend}, // Mn [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA - {0x115BE, 0x115BE, prExtend}, // Mc SIDDHAM SIGN VISARGA - {0x115BF, 0x115C0, prExtend}, // Mn [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA - {0x115C2, 0x115C3, prSTerm}, // Po [2] SIDDHAM DANDA..SIDDHAM DOUBLE DANDA - {0x115C9, 0x115D7, prSTerm}, // Po [15] SIDDHAM END OF TEXT MARK..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES - {0x115D8, 0x115DB, prOLetter}, // Lo [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U - {0x115DC, 0x115DD, prExtend}, // Mn [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU - {0x11600, 0x1162F, prOLetter}, // Lo [48] MODI LETTER A..MODI LETTER LLA - {0x11630, 0x11632, prExtend}, // Mc [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II - {0x11633, 0x1163A, prExtend}, // Mn [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI - {0x1163B, 0x1163C, prExtend}, // Mc [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU - {0x1163D, 0x1163D, prExtend}, // Mn MODI SIGN ANUSVARA - {0x1163E, 0x1163E, prExtend}, // Mc MODI SIGN VISARGA - {0x1163F, 0x11640, prExtend}, // Mn [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA - {0x11641, 0x11642, prSTerm}, // Po [2] MODI DANDA..MODI DOUBLE DANDA - {0x11644, 0x11644, prOLetter}, // Lo MODI SIGN HUVA - {0x11650, 0x11659, prNumeric}, // Nd [10] MODI DIGIT ZERO..MODI DIGIT NINE - {0x11680, 0x116AA, prOLetter}, // Lo [43] TAKRI LETTER A..TAKRI LETTER RRA - {0x116AB, 0x116AB, prExtend}, // Mn TAKRI SIGN ANUSVARA - {0x116AC, 0x116AC, prExtend}, // Mc TAKRI SIGN VISARGA - {0x116AD, 0x116AD, prExtend}, // Mn TAKRI VOWEL SIGN AA - {0x116AE, 0x116AF, prExtend}, // Mc [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II - {0x116B0, 0x116B5, prExtend}, // Mn [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU - {0x116B6, 0x116B6, prExtend}, // Mc TAKRI SIGN VIRAMA - {0x116B7, 0x116B7, prExtend}, // Mn TAKRI SIGN NUKTA - {0x116B8, 0x116B8, prOLetter}, // Lo TAKRI LETTER ARCHAIC KHA - {0x116C0, 0x116C9, prNumeric}, // Nd [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE - {0x11700, 0x1171A, prOLetter}, // Lo [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA - {0x1171D, 0x1171F, prExtend}, // Mn [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA - {0x11720, 0x11721, prExtend}, // Mc [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA - {0x11722, 0x11725, prExtend}, // Mn [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU - {0x11726, 0x11726, prExtend}, // Mc AHOM VOWEL SIGN E - {0x11727, 0x1172B, prExtend}, // Mn [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER - {0x11730, 0x11739, prNumeric}, // Nd [10] AHOM DIGIT ZERO..AHOM DIGIT NINE - {0x1173C, 0x1173E, prSTerm}, // Po [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI - {0x11740, 0x11746, prOLetter}, // Lo [7] AHOM LETTER CA..AHOM LETTER LLA - {0x11800, 0x1182B, prOLetter}, // Lo [44] DOGRA LETTER A..DOGRA LETTER RRA - {0x1182C, 0x1182E, prExtend}, // Mc [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II - {0x1182F, 0x11837, prExtend}, // Mn [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA - {0x11838, 0x11838, prExtend}, // Mc DOGRA SIGN VISARGA - {0x11839, 0x1183A, prExtend}, // Mn [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA - {0x118A0, 0x118BF, prUpper}, // L& [32] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI CAPITAL LETTER VIYO - {0x118C0, 0x118DF, prLower}, // L& [32] WARANG CITI SMALL LETTER NGAA..WARANG CITI SMALL LETTER VIYO - {0x118E0, 0x118E9, prNumeric}, // Nd [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE - {0x118FF, 0x11906, prOLetter}, // Lo [8] WARANG CITI OM..DIVES AKURU LETTER E - {0x11909, 0x11909, prOLetter}, // Lo DIVES AKURU LETTER O - {0x1190C, 0x11913, prOLetter}, // Lo [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA - {0x11915, 0x11916, prOLetter}, // Lo [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA - {0x11918, 0x1192F, prOLetter}, // Lo [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA - {0x11930, 0x11935, prExtend}, // Mc [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E - {0x11937, 0x11938, prExtend}, // Mc [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O - {0x1193B, 0x1193C, prExtend}, // Mn [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU - {0x1193D, 0x1193D, prExtend}, // Mc DIVES AKURU SIGN HALANTA - {0x1193E, 0x1193E, prExtend}, // Mn DIVES AKURU VIRAMA - {0x1193F, 0x1193F, prOLetter}, // Lo DIVES AKURU PREFIXED NASAL SIGN - {0x11940, 0x11940, prExtend}, // Mc DIVES AKURU MEDIAL YA - {0x11941, 0x11941, prOLetter}, // Lo DIVES AKURU INITIAL RA - {0x11942, 0x11942, prExtend}, // Mc DIVES AKURU MEDIAL RA - {0x11943, 0x11943, prExtend}, // Mn DIVES AKURU SIGN NUKTA - {0x11944, 0x11944, prSTerm}, // Po DIVES AKURU DOUBLE DANDA - {0x11946, 0x11946, prSTerm}, // Po DIVES AKURU END OF TEXT MARK - {0x11950, 0x11959, prNumeric}, // Nd [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE - {0x119A0, 0x119A7, prOLetter}, // Lo [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR - {0x119AA, 0x119D0, prOLetter}, // Lo [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA - {0x119D1, 0x119D3, prExtend}, // Mc [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II - {0x119D4, 0x119D7, prExtend}, // Mn [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR - {0x119DA, 0x119DB, prExtend}, // Mn [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI - {0x119DC, 0x119DF, prExtend}, // Mc [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA - {0x119E0, 0x119E0, prExtend}, // Mn NANDINAGARI SIGN VIRAMA - {0x119E1, 0x119E1, prOLetter}, // Lo NANDINAGARI SIGN AVAGRAHA - {0x119E3, 0x119E3, prOLetter}, // Lo NANDINAGARI HEADSTROKE - {0x119E4, 0x119E4, prExtend}, // Mc NANDINAGARI VOWEL SIGN PRISHTHAMATRA E - {0x11A00, 0x11A00, prOLetter}, // Lo ZANABAZAR SQUARE LETTER A - {0x11A01, 0x11A0A, prExtend}, // Mn [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK - {0x11A0B, 0x11A32, prOLetter}, // Lo [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA - {0x11A33, 0x11A38, prExtend}, // Mn [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA - {0x11A39, 0x11A39, prExtend}, // Mc ZANABAZAR SQUARE SIGN VISARGA - {0x11A3A, 0x11A3A, prOLetter}, // Lo ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA - {0x11A3B, 0x11A3E, prExtend}, // Mn [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA - {0x11A42, 0x11A43, prSTerm}, // Po [2] ZANABAZAR SQUARE MARK SHAD..ZANABAZAR SQUARE MARK DOUBLE SHAD - {0x11A47, 0x11A47, prExtend}, // Mn ZANABAZAR SQUARE SUBJOINER - {0x11A50, 0x11A50, prOLetter}, // Lo SOYOMBO LETTER A - {0x11A51, 0x11A56, prExtend}, // Mn [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE - {0x11A57, 0x11A58, prExtend}, // Mc [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU - {0x11A59, 0x11A5B, prExtend}, // Mn [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK - {0x11A5C, 0x11A89, prOLetter}, // Lo [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA - {0x11A8A, 0x11A96, prExtend}, // Mn [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA - {0x11A97, 0x11A97, prExtend}, // Mc SOYOMBO SIGN VISARGA - {0x11A98, 0x11A99, prExtend}, // Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER - {0x11A9B, 0x11A9C, prSTerm}, // Po [2] SOYOMBO MARK SHAD..SOYOMBO MARK DOUBLE SHAD - {0x11A9D, 0x11A9D, prOLetter}, // Lo SOYOMBO MARK PLUTA - {0x11AB0, 0x11AF8, prOLetter}, // Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL - {0x11C00, 0x11C08, prOLetter}, // Lo [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L - {0x11C0A, 0x11C2E, prOLetter}, // Lo [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA - {0x11C2F, 0x11C2F, prExtend}, // Mc BHAIKSUKI VOWEL SIGN AA - {0x11C30, 0x11C36, prExtend}, // Mn [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L - {0x11C38, 0x11C3D, prExtend}, // Mn [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA - {0x11C3E, 0x11C3E, prExtend}, // Mc BHAIKSUKI SIGN VISARGA - {0x11C3F, 0x11C3F, prExtend}, // Mn BHAIKSUKI SIGN VIRAMA - {0x11C40, 0x11C40, prOLetter}, // Lo BHAIKSUKI SIGN AVAGRAHA - {0x11C41, 0x11C42, prSTerm}, // Po [2] BHAIKSUKI DANDA..BHAIKSUKI DOUBLE DANDA - {0x11C50, 0x11C59, prNumeric}, // Nd [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE - {0x11C72, 0x11C8F, prOLetter}, // Lo [30] MARCHEN LETTER KA..MARCHEN LETTER A - {0x11C92, 0x11CA7, prExtend}, // Mn [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA - {0x11CA9, 0x11CA9, prExtend}, // Mc MARCHEN SUBJOINED LETTER YA - {0x11CAA, 0x11CB0, prExtend}, // Mn [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA - {0x11CB1, 0x11CB1, prExtend}, // Mc MARCHEN VOWEL SIGN I - {0x11CB2, 0x11CB3, prExtend}, // Mn [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E - {0x11CB4, 0x11CB4, prExtend}, // Mc MARCHEN VOWEL SIGN O - {0x11CB5, 0x11CB6, prExtend}, // Mn [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU - {0x11D00, 0x11D06, prOLetter}, // Lo [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E - {0x11D08, 0x11D09, prOLetter}, // Lo [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O - {0x11D0B, 0x11D30, prOLetter}, // Lo [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA - {0x11D31, 0x11D36, prExtend}, // Mn [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R - {0x11D3A, 0x11D3A, prExtend}, // Mn MASARAM GONDI VOWEL SIGN E - {0x11D3C, 0x11D3D, prExtend}, // Mn [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O - {0x11D3F, 0x11D45, prExtend}, // Mn [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA - {0x11D46, 0x11D46, prOLetter}, // Lo MASARAM GONDI REPHA - {0x11D47, 0x11D47, prExtend}, // Mn MASARAM GONDI RA-KARA - {0x11D50, 0x11D59, prNumeric}, // Nd [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE - {0x11D60, 0x11D65, prOLetter}, // Lo [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU - {0x11D67, 0x11D68, prOLetter}, // Lo [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI - {0x11D6A, 0x11D89, prOLetter}, // Lo [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA - {0x11D8A, 0x11D8E, prExtend}, // Mc [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU - {0x11D90, 0x11D91, prExtend}, // Mn [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI - {0x11D93, 0x11D94, prExtend}, // Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU - {0x11D95, 0x11D95, prExtend}, // Mn GUNJALA GONDI SIGN ANUSVARA - {0x11D96, 0x11D96, prExtend}, // Mc GUNJALA GONDI SIGN VISARGA - {0x11D97, 0x11D97, prExtend}, // Mn GUNJALA GONDI VIRAMA - {0x11D98, 0x11D98, prOLetter}, // Lo GUNJALA GONDI OM - {0x11DA0, 0x11DA9, prNumeric}, // Nd [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE - {0x11EE0, 0x11EF2, prOLetter}, // Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA - {0x11EF3, 0x11EF4, prExtend}, // Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U - {0x11EF5, 0x11EF6, prExtend}, // Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O - {0x11EF7, 0x11EF8, prSTerm}, // Po [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION - {0x11F00, 0x11F01, prExtend}, // Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA - {0x11F02, 0x11F02, prOLetter}, // Lo KAWI SIGN REPHA - {0x11F03, 0x11F03, prExtend}, // Mc KAWI SIGN VISARGA - {0x11F04, 0x11F10, prOLetter}, // Lo [13] KAWI LETTER A..KAWI LETTER O - {0x11F12, 0x11F33, prOLetter}, // Lo [34] KAWI LETTER KA..KAWI LETTER JNYA - {0x11F34, 0x11F35, prExtend}, // Mc [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA - {0x11F36, 0x11F3A, prExtend}, // Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R - {0x11F3E, 0x11F3F, prExtend}, // Mc [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI - {0x11F40, 0x11F40, prExtend}, // Mn KAWI VOWEL SIGN EU - {0x11F41, 0x11F41, prExtend}, // Mc KAWI SIGN KILLER - {0x11F42, 0x11F42, prExtend}, // Mn KAWI CONJOINER - {0x11F43, 0x11F44, prSTerm}, // Po [2] KAWI DANDA..KAWI DOUBLE DANDA - {0x11F50, 0x11F59, prNumeric}, // Nd [10] KAWI DIGIT ZERO..KAWI DIGIT NINE - {0x11FB0, 0x11FB0, prOLetter}, // Lo LISU LETTER YHA - {0x12000, 0x12399, prOLetter}, // Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U - {0x12400, 0x1246E, prOLetter}, // Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM - {0x12480, 0x12543, prOLetter}, // Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU - {0x12F90, 0x12FF0, prOLetter}, // Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 - {0x13000, 0x1342F, prOLetter}, // Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D - {0x13430, 0x1343F, prFormat}, // Cf [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE - {0x13440, 0x13440, prExtend}, // Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY - {0x13441, 0x13446, prOLetter}, // Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN - {0x13447, 0x13455, prExtend}, // Mn [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED - {0x14400, 0x14646, prOLetter}, // Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530 - {0x16800, 0x16A38, prOLetter}, // Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ - {0x16A40, 0x16A5E, prOLetter}, // Lo [31] MRO LETTER TA..MRO LETTER TEK - {0x16A60, 0x16A69, prNumeric}, // Nd [10] MRO DIGIT ZERO..MRO DIGIT NINE - {0x16A6E, 0x16A6F, prSTerm}, // Po [2] MRO DANDA..MRO DOUBLE DANDA - {0x16A70, 0x16ABE, prOLetter}, // Lo [79] TANGSA LETTER OZ..TANGSA LETTER ZA - {0x16AC0, 0x16AC9, prNumeric}, // Nd [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE - {0x16AD0, 0x16AED, prOLetter}, // Lo [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I - {0x16AF0, 0x16AF4, prExtend}, // Mn [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE - {0x16AF5, 0x16AF5, prSTerm}, // Po BASSA VAH FULL STOP - {0x16B00, 0x16B2F, prOLetter}, // Lo [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU - {0x16B30, 0x16B36, prExtend}, // Mn [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM - {0x16B37, 0x16B38, prSTerm}, // Po [2] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS TSHAB CEEB - {0x16B40, 0x16B43, prOLetter}, // Lm [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM - {0x16B44, 0x16B44, prSTerm}, // Po PAHAWH HMONG SIGN XAUS - {0x16B50, 0x16B59, prNumeric}, // Nd [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE - {0x16B63, 0x16B77, prOLetter}, // Lo [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS - {0x16B7D, 0x16B8F, prOLetter}, // Lo [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ - {0x16E40, 0x16E5F, prUpper}, // L& [32] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN CAPITAL LETTER Y - {0x16E60, 0x16E7F, prLower}, // L& [32] MEDEFAIDRIN SMALL LETTER M..MEDEFAIDRIN SMALL LETTER Y - {0x16E98, 0x16E98, prSTerm}, // Po MEDEFAIDRIN FULL STOP - {0x16F00, 0x16F4A, prOLetter}, // Lo [75] MIAO LETTER PA..MIAO LETTER RTE - {0x16F4F, 0x16F4F, prExtend}, // Mn MIAO SIGN CONSONANT MODIFIER BAR - {0x16F50, 0x16F50, prOLetter}, // Lo MIAO LETTER NASALIZATION - {0x16F51, 0x16F87, prExtend}, // Mc [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI - {0x16F8F, 0x16F92, prExtend}, // Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW - {0x16F93, 0x16F9F, prOLetter}, // Lm [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8 - {0x16FE0, 0x16FE1, prOLetter}, // Lm [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK - {0x16FE3, 0x16FE3, prOLetter}, // Lm OLD CHINESE ITERATION MARK - {0x16FE4, 0x16FE4, prExtend}, // Mn KHITAN SMALL SCRIPT FILLER - {0x16FF0, 0x16FF1, prExtend}, // Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY - {0x17000, 0x187F7, prOLetter}, // Lo [6136] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187F7 - {0x18800, 0x18CD5, prOLetter}, // Lo [1238] TANGUT COMPONENT-001..KHITAN SMALL SCRIPT CHARACTER-18CD5 - {0x18D00, 0x18D08, prOLetter}, // Lo [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08 - {0x1AFF0, 0x1AFF3, prOLetter}, // Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 - {0x1AFF5, 0x1AFFB, prOLetter}, // Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 - {0x1AFFD, 0x1AFFE, prOLetter}, // Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 - {0x1B000, 0x1B122, prOLetter}, // Lo [291] KATAKANA LETTER ARCHAIC E..KATAKANA LETTER ARCHAIC WU - {0x1B132, 0x1B132, prOLetter}, // Lo HIRAGANA LETTER SMALL KO - {0x1B150, 0x1B152, prOLetter}, // Lo [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO - {0x1B155, 0x1B155, prOLetter}, // Lo KATAKANA LETTER SMALL KO - {0x1B164, 0x1B167, prOLetter}, // Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N - {0x1B170, 0x1B2FB, prOLetter}, // Lo [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB - {0x1BC00, 0x1BC6A, prOLetter}, // Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M - {0x1BC70, 0x1BC7C, prOLetter}, // Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK - {0x1BC80, 0x1BC88, prOLetter}, // Lo [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL - {0x1BC90, 0x1BC99, prOLetter}, // Lo [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW - {0x1BC9D, 0x1BC9E, prExtend}, // Mn [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK - {0x1BC9F, 0x1BC9F, prSTerm}, // Po DUPLOYAN PUNCTUATION CHINOOK FULL STOP - {0x1BCA0, 0x1BCA3, prFormat}, // Cf [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP - {0x1CF00, 0x1CF2D, prExtend}, // Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT - {0x1CF30, 0x1CF46, prExtend}, // Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG - {0x1D165, 0x1D166, prExtend}, // Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM - {0x1D167, 0x1D169, prExtend}, // Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 - {0x1D16D, 0x1D172, prExtend}, // Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 - {0x1D173, 0x1D17A, prFormat}, // Cf [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE - {0x1D17B, 0x1D182, prExtend}, // Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE - {0x1D185, 0x1D18B, prExtend}, // Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE - {0x1D1AA, 0x1D1AD, prExtend}, // Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO - {0x1D242, 0x1D244, prExtend}, // Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME - {0x1D400, 0x1D419, prUpper}, // L& [26] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL BOLD CAPITAL Z - {0x1D41A, 0x1D433, prLower}, // L& [26] MATHEMATICAL BOLD SMALL A..MATHEMATICAL BOLD SMALL Z - {0x1D434, 0x1D44D, prUpper}, // L& [26] MATHEMATICAL ITALIC CAPITAL A..MATHEMATICAL ITALIC CAPITAL Z - {0x1D44E, 0x1D454, prLower}, // L& [7] MATHEMATICAL ITALIC SMALL A..MATHEMATICAL ITALIC SMALL G - {0x1D456, 0x1D467, prLower}, // L& [18] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL ITALIC SMALL Z - {0x1D468, 0x1D481, prUpper}, // L& [26] MATHEMATICAL BOLD ITALIC CAPITAL A..MATHEMATICAL BOLD ITALIC CAPITAL Z - {0x1D482, 0x1D49B, prLower}, // L& [26] MATHEMATICAL BOLD ITALIC SMALL A..MATHEMATICAL BOLD ITALIC SMALL Z - {0x1D49C, 0x1D49C, prUpper}, // L& MATHEMATICAL SCRIPT CAPITAL A - {0x1D49E, 0x1D49F, prUpper}, // L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D - {0x1D4A2, 0x1D4A2, prUpper}, // L& MATHEMATICAL SCRIPT CAPITAL G - {0x1D4A5, 0x1D4A6, prUpper}, // L& [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K - {0x1D4A9, 0x1D4AC, prUpper}, // L& [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q - {0x1D4AE, 0x1D4B5, prUpper}, // L& [8] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT CAPITAL Z - {0x1D4B6, 0x1D4B9, prLower}, // L& [4] MATHEMATICAL SCRIPT SMALL A..MATHEMATICAL SCRIPT SMALL D - {0x1D4BB, 0x1D4BB, prLower}, // L& MATHEMATICAL SCRIPT SMALL F - {0x1D4BD, 0x1D4C3, prLower}, // L& [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N - {0x1D4C5, 0x1D4CF, prLower}, // L& [11] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL SCRIPT SMALL Z - {0x1D4D0, 0x1D4E9, prUpper}, // L& [26] MATHEMATICAL BOLD SCRIPT CAPITAL A..MATHEMATICAL BOLD SCRIPT CAPITAL Z - {0x1D4EA, 0x1D503, prLower}, // L& [26] MATHEMATICAL BOLD SCRIPT SMALL A..MATHEMATICAL BOLD SCRIPT SMALL Z - {0x1D504, 0x1D505, prUpper}, // L& [2] MATHEMATICAL FRAKTUR CAPITAL A..MATHEMATICAL FRAKTUR CAPITAL B - {0x1D507, 0x1D50A, prUpper}, // L& [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G - {0x1D50D, 0x1D514, prUpper}, // L& [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q - {0x1D516, 0x1D51C, prUpper}, // L& [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y - {0x1D51E, 0x1D537, prLower}, // L& [26] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL FRAKTUR SMALL Z - {0x1D538, 0x1D539, prUpper}, // L& [2] MATHEMATICAL DOUBLE-STRUCK CAPITAL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B - {0x1D53B, 0x1D53E, prUpper}, // L& [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G - {0x1D540, 0x1D544, prUpper}, // L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M - {0x1D546, 0x1D546, prUpper}, // L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O - {0x1D54A, 0x1D550, prUpper}, // L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y - {0x1D552, 0x1D56B, prLower}, // L& [26] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL DOUBLE-STRUCK SMALL Z - {0x1D56C, 0x1D585, prUpper}, // L& [26] MATHEMATICAL BOLD FRAKTUR CAPITAL A..MATHEMATICAL BOLD FRAKTUR CAPITAL Z - {0x1D586, 0x1D59F, prLower}, // L& [26] MATHEMATICAL BOLD FRAKTUR SMALL A..MATHEMATICAL BOLD FRAKTUR SMALL Z - {0x1D5A0, 0x1D5B9, prUpper}, // L& [26] MATHEMATICAL SANS-SERIF CAPITAL A..MATHEMATICAL SANS-SERIF CAPITAL Z - {0x1D5BA, 0x1D5D3, prLower}, // L& [26] MATHEMATICAL SANS-SERIF SMALL A..MATHEMATICAL SANS-SERIF SMALL Z - {0x1D5D4, 0x1D5ED, prUpper}, // L& [26] MATHEMATICAL SANS-SERIF BOLD CAPITAL A..MATHEMATICAL SANS-SERIF BOLD CAPITAL Z - {0x1D5EE, 0x1D607, prLower}, // L& [26] MATHEMATICAL SANS-SERIF BOLD SMALL A..MATHEMATICAL SANS-SERIF BOLD SMALL Z - {0x1D608, 0x1D621, prUpper}, // L& [26] MATHEMATICAL SANS-SERIF ITALIC CAPITAL A..MATHEMATICAL SANS-SERIF ITALIC CAPITAL Z - {0x1D622, 0x1D63B, prLower}, // L& [26] MATHEMATICAL SANS-SERIF ITALIC SMALL A..MATHEMATICAL SANS-SERIF ITALIC SMALL Z - {0x1D63C, 0x1D655, prUpper}, // L& [26] MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL A..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL Z - {0x1D656, 0x1D66F, prLower}, // L& [26] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL A..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL Z - {0x1D670, 0x1D689, prUpper}, // L& [26] MATHEMATICAL MONOSPACE CAPITAL A..MATHEMATICAL MONOSPACE CAPITAL Z - {0x1D68A, 0x1D6A5, prLower}, // L& [28] MATHEMATICAL MONOSPACE SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J - {0x1D6A8, 0x1D6C0, prUpper}, // L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA - {0x1D6C2, 0x1D6DA, prLower}, // L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA - {0x1D6DC, 0x1D6E1, prLower}, // L& [6] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL BOLD PI SYMBOL - {0x1D6E2, 0x1D6FA, prUpper}, // L& [25] MATHEMATICAL ITALIC CAPITAL ALPHA..MATHEMATICAL ITALIC CAPITAL OMEGA - {0x1D6FC, 0x1D714, prLower}, // L& [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA - {0x1D716, 0x1D71B, prLower}, // L& [6] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL ITALIC PI SYMBOL - {0x1D71C, 0x1D734, prUpper}, // L& [25] MATHEMATICAL BOLD ITALIC CAPITAL ALPHA..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA - {0x1D736, 0x1D74E, prLower}, // L& [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA - {0x1D750, 0x1D755, prLower}, // L& [6] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC PI SYMBOL - {0x1D756, 0x1D76E, prUpper}, // L& [25] MATHEMATICAL SANS-SERIF BOLD CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA - {0x1D770, 0x1D788, prLower}, // L& [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA - {0x1D78A, 0x1D78F, prLower}, // L& [6] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD PI SYMBOL - {0x1D790, 0x1D7A8, prUpper}, // L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA - {0x1D7AA, 0x1D7C2, prLower}, // L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA - {0x1D7C4, 0x1D7C9, prLower}, // L& [6] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC PI SYMBOL - {0x1D7CA, 0x1D7CA, prUpper}, // L& MATHEMATICAL BOLD CAPITAL DIGAMMA - {0x1D7CB, 0x1D7CB, prLower}, // L& MATHEMATICAL BOLD SMALL DIGAMMA - {0x1D7CE, 0x1D7FF, prNumeric}, // Nd [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE - {0x1DA00, 0x1DA36, prExtend}, // Mn [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN - {0x1DA3B, 0x1DA6C, prExtend}, // Mn [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT - {0x1DA75, 0x1DA75, prExtend}, // Mn SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS - {0x1DA84, 0x1DA84, prExtend}, // Mn SIGNWRITING LOCATION HEAD NECK - {0x1DA88, 0x1DA88, prSTerm}, // Po SIGNWRITING FULL STOP - {0x1DA9B, 0x1DA9F, prExtend}, // Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 - {0x1DAA1, 0x1DAAF, prExtend}, // Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 - {0x1DF00, 0x1DF09, prLower}, // L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK - {0x1DF0A, 0x1DF0A, prOLetter}, // Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK - {0x1DF0B, 0x1DF1E, prLower}, // L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL - {0x1DF25, 0x1DF2A, prLower}, // L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK - {0x1E000, 0x1E006, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE - {0x1E008, 0x1E018, prExtend}, // Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU - {0x1E01B, 0x1E021, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI - {0x1E023, 0x1E024, prExtend}, // Mn [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS - {0x1E026, 0x1E02A, prExtend}, // Mn [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA - {0x1E030, 0x1E06D, prLower}, // Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE - {0x1E08F, 0x1E08F, prExtend}, // Mn COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I - {0x1E100, 0x1E12C, prOLetter}, // Lo [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W - {0x1E130, 0x1E136, prExtend}, // Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D - {0x1E137, 0x1E13D, prOLetter}, // Lm [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER - {0x1E140, 0x1E149, prNumeric}, // Nd [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE - {0x1E14E, 0x1E14E, prOLetter}, // Lo NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ - {0x1E290, 0x1E2AD, prOLetter}, // Lo [30] TOTO LETTER PA..TOTO LETTER A - {0x1E2AE, 0x1E2AE, prExtend}, // Mn TOTO SIGN RISING TONE - {0x1E2C0, 0x1E2EB, prOLetter}, // Lo [44] WANCHO LETTER AA..WANCHO LETTER YIH - {0x1E2EC, 0x1E2EF, prExtend}, // Mn [4] WANCHO TONE TUP..WANCHO TONE KOINI - {0x1E2F0, 0x1E2F9, prNumeric}, // Nd [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE - {0x1E4D0, 0x1E4EA, prOLetter}, // Lo [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL - {0x1E4EB, 0x1E4EB, prOLetter}, // Lm NAG MUNDARI SIGN OJOD - {0x1E4EC, 0x1E4EF, prExtend}, // Mn [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH - {0x1E4F0, 0x1E4F9, prNumeric}, // Nd [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE - {0x1E7E0, 0x1E7E6, prOLetter}, // Lo [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO - {0x1E7E8, 0x1E7EB, prOLetter}, // Lo [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE - {0x1E7ED, 0x1E7EE, prOLetter}, // Lo [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE - {0x1E7F0, 0x1E7FE, prOLetter}, // Lo [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE - {0x1E800, 0x1E8C4, prOLetter}, // Lo [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON - {0x1E8D0, 0x1E8D6, prExtend}, // Mn [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS - {0x1E900, 0x1E921, prUpper}, // L& [34] ADLAM CAPITAL LETTER ALIF..ADLAM CAPITAL LETTER SHA - {0x1E922, 0x1E943, prLower}, // L& [34] ADLAM SMALL LETTER ALIF..ADLAM SMALL LETTER SHA - {0x1E944, 0x1E94A, prExtend}, // Mn [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA - {0x1E94B, 0x1E94B, prOLetter}, // Lm ADLAM NASALIZATION MARK - {0x1E950, 0x1E959, prNumeric}, // Nd [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE - {0x1EE00, 0x1EE03, prOLetter}, // Lo [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL - {0x1EE05, 0x1EE1F, prOLetter}, // Lo [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF - {0x1EE21, 0x1EE22, prOLetter}, // Lo [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM - {0x1EE24, 0x1EE24, prOLetter}, // Lo ARABIC MATHEMATICAL INITIAL HEH - {0x1EE27, 0x1EE27, prOLetter}, // Lo ARABIC MATHEMATICAL INITIAL HAH - {0x1EE29, 0x1EE32, prOLetter}, // Lo [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF - {0x1EE34, 0x1EE37, prOLetter}, // Lo [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH - {0x1EE39, 0x1EE39, prOLetter}, // Lo ARABIC MATHEMATICAL INITIAL DAD - {0x1EE3B, 0x1EE3B, prOLetter}, // Lo ARABIC MATHEMATICAL INITIAL GHAIN - {0x1EE42, 0x1EE42, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED JEEM - {0x1EE47, 0x1EE47, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED HAH - {0x1EE49, 0x1EE49, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED YEH - {0x1EE4B, 0x1EE4B, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED LAM - {0x1EE4D, 0x1EE4F, prOLetter}, // Lo [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN - {0x1EE51, 0x1EE52, prOLetter}, // Lo [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF - {0x1EE54, 0x1EE54, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED SHEEN - {0x1EE57, 0x1EE57, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED KHAH - {0x1EE59, 0x1EE59, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED DAD - {0x1EE5B, 0x1EE5B, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED GHAIN - {0x1EE5D, 0x1EE5D, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS NOON - {0x1EE5F, 0x1EE5F, prOLetter}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS QAF - {0x1EE61, 0x1EE62, prOLetter}, // Lo [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM - {0x1EE64, 0x1EE64, prOLetter}, // Lo ARABIC MATHEMATICAL STRETCHED HEH - {0x1EE67, 0x1EE6A, prOLetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF - {0x1EE6C, 0x1EE72, prOLetter}, // Lo [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF - {0x1EE74, 0x1EE77, prOLetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH - {0x1EE79, 0x1EE7C, prOLetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH - {0x1EE7E, 0x1EE7E, prOLetter}, // Lo ARABIC MATHEMATICAL STRETCHED DOTLESS FEH - {0x1EE80, 0x1EE89, prOLetter}, // Lo [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH - {0x1EE8B, 0x1EE9B, prOLetter}, // Lo [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN - {0x1EEA1, 0x1EEA3, prOLetter}, // Lo [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL - {0x1EEA5, 0x1EEA9, prOLetter}, // Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH - {0x1EEAB, 0x1EEBB, prOLetter}, // Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN - {0x1F130, 0x1F149, prUpper}, // So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z - {0x1F150, 0x1F169, prUpper}, // So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z - {0x1F170, 0x1F189, prUpper}, // So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z - {0x1F676, 0x1F678, prClose}, // So [3] SANS-SERIF HEAVY DOUBLE TURNED COMMA QUOTATION MARK ORNAMENT..SANS-SERIF HEAVY LOW DOUBLE COMMA QUOTATION MARK ORNAMENT - {0x1FBF0, 0x1FBF9, prNumeric}, // Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE - {0x20000, 0x2A6DF, prOLetter}, // Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF - {0x2A700, 0x2B739, prOLetter}, // Lo [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739 - {0x2B740, 0x2B81D, prOLetter}, // Lo [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D - {0x2B820, 0x2CEA1, prOLetter}, // Lo [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1 - {0x2CEB0, 0x2EBE0, prOLetter}, // Lo [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0 - {0x2F800, 0x2FA1D, prOLetter}, // Lo [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D - {0x30000, 0x3134A, prOLetter}, // Lo [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A - {0x31350, 0x323AF, prOLetter}, // Lo [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF - {0xE0001, 0xE0001, prFormat}, // Cf LANGUAGE TAG - {0xE0020, 0xE007F, prExtend}, // Cf [96] TAG SPACE..CANCEL TAG - {0xE0100, 0xE01EF, prExtend}, // Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 -} diff --git a/vendor/github.com/rivo/uniseg/sentencerules.go b/vendor/github.com/rivo/uniseg/sentencerules.go deleted file mode 100644 index 0b29c7b..0000000 --- a/vendor/github.com/rivo/uniseg/sentencerules.go +++ /dev/null @@ -1,276 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// The states of the sentence break parser. -const ( - sbAny = iota - sbCR - sbParaSep - sbATerm - sbUpper - sbLower - sbSB7 - sbSB8Close - sbSB8Sp - sbSTerm - sbSB8aClose - sbSB8aSp -) - -// sbTransitions implements the sentence break parser's state transitions. It's -// anologous to [grTransitions], see comments there for details. -// -// Unicode version 15.0.0. -func sbTransitions(state, prop int) (newState int, sentenceBreak bool, rule int) { - switch uint64(state) | uint64(prop)<<32 { - // SB3. - case sbAny | prCR<<32: - return sbCR, false, 9990 - case sbCR | prLF<<32: - return sbParaSep, false, 30 - - // SB4. - case sbAny | prSep<<32: - return sbParaSep, false, 9990 - case sbAny | prLF<<32: - return sbParaSep, false, 9990 - case sbParaSep | prAny<<32: - return sbAny, true, 40 - case sbCR | prAny<<32: - return sbAny, true, 40 - - // SB6. - case sbAny | prATerm<<32: - return sbATerm, false, 9990 - case sbATerm | prNumeric<<32: - return sbAny, false, 60 - case sbSB7 | prNumeric<<32: - return sbAny, false, 60 // Because ATerm also appears in SB7. - - // SB7. - case sbAny | prUpper<<32: - return sbUpper, false, 9990 - case sbAny | prLower<<32: - return sbLower, false, 9990 - case sbUpper | prATerm<<32: - return sbSB7, false, 70 - case sbLower | prATerm<<32: - return sbSB7, false, 70 - case sbSB7 | prUpper<<32: - return sbUpper, false, 70 - - // SB8a. - case sbAny | prSTerm<<32: - return sbSTerm, false, 9990 - case sbATerm | prSContinue<<32: - return sbAny, false, 81 - case sbATerm | prATerm<<32: - return sbATerm, false, 81 - case sbATerm | prSTerm<<32: - return sbSTerm, false, 81 - case sbSB7 | prSContinue<<32: - return sbAny, false, 81 - case sbSB7 | prATerm<<32: - return sbATerm, false, 81 - case sbSB7 | prSTerm<<32: - return sbSTerm, false, 81 - case sbSB8Close | prSContinue<<32: - return sbAny, false, 81 - case sbSB8Close | prATerm<<32: - return sbATerm, false, 81 - case sbSB8Close | prSTerm<<32: - return sbSTerm, false, 81 - case sbSB8Sp | prSContinue<<32: - return sbAny, false, 81 - case sbSB8Sp | prATerm<<32: - return sbATerm, false, 81 - case sbSB8Sp | prSTerm<<32: - return sbSTerm, false, 81 - case sbSTerm | prSContinue<<32: - return sbAny, false, 81 - case sbSTerm | prATerm<<32: - return sbATerm, false, 81 - case sbSTerm | prSTerm<<32: - return sbSTerm, false, 81 - case sbSB8aClose | prSContinue<<32: - return sbAny, false, 81 - case sbSB8aClose | prATerm<<32: - return sbATerm, false, 81 - case sbSB8aClose | prSTerm<<32: - return sbSTerm, false, 81 - case sbSB8aSp | prSContinue<<32: - return sbAny, false, 81 - case sbSB8aSp | prATerm<<32: - return sbATerm, false, 81 - case sbSB8aSp | prSTerm<<32: - return sbSTerm, false, 81 - - // SB9. - case sbATerm | prClose<<32: - return sbSB8Close, false, 90 - case sbSB7 | prClose<<32: - return sbSB8Close, false, 90 - case sbSB8Close | prClose<<32: - return sbSB8Close, false, 90 - case sbATerm | prSp<<32: - return sbSB8Sp, false, 90 - case sbSB7 | prSp<<32: - return sbSB8Sp, false, 90 - case sbSB8Close | prSp<<32: - return sbSB8Sp, false, 90 - case sbSTerm | prClose<<32: - return sbSB8aClose, false, 90 - case sbSB8aClose | prClose<<32: - return sbSB8aClose, false, 90 - case sbSTerm | prSp<<32: - return sbSB8aSp, false, 90 - case sbSB8aClose | prSp<<32: - return sbSB8aSp, false, 90 - case sbATerm | prSep<<32: - return sbParaSep, false, 90 - case sbATerm | prCR<<32: - return sbParaSep, false, 90 - case sbATerm | prLF<<32: - return sbParaSep, false, 90 - case sbSB7 | prSep<<32: - return sbParaSep, false, 90 - case sbSB7 | prCR<<32: - return sbParaSep, false, 90 - case sbSB7 | prLF<<32: - return sbParaSep, false, 90 - case sbSB8Close | prSep<<32: - return sbParaSep, false, 90 - case sbSB8Close | prCR<<32: - return sbParaSep, false, 90 - case sbSB8Close | prLF<<32: - return sbParaSep, false, 90 - case sbSTerm | prSep<<32: - return sbParaSep, false, 90 - case sbSTerm | prCR<<32: - return sbParaSep, false, 90 - case sbSTerm | prLF<<32: - return sbParaSep, false, 90 - case sbSB8aClose | prSep<<32: - return sbParaSep, false, 90 - case sbSB8aClose | prCR<<32: - return sbParaSep, false, 90 - case sbSB8aClose | prLF<<32: - return sbParaSep, false, 90 - - // SB10. - case sbSB8Sp | prSp<<32: - return sbSB8Sp, false, 100 - case sbSB8aSp | prSp<<32: - return sbSB8aSp, false, 100 - case sbSB8Sp | prSep<<32: - return sbParaSep, false, 100 - case sbSB8Sp | prCR<<32: - return sbParaSep, false, 100 - case sbSB8Sp | prLF<<32: - return sbParaSep, false, 100 - - // SB11. - case sbATerm | prAny<<32: - return sbAny, true, 110 - case sbSB7 | prAny<<32: - return sbAny, true, 110 - case sbSB8Close | prAny<<32: - return sbAny, true, 110 - case sbSB8Sp | prAny<<32: - return sbAny, true, 110 - case sbSTerm | prAny<<32: - return sbAny, true, 110 - case sbSB8aClose | prAny<<32: - return sbAny, true, 110 - case sbSB8aSp | prAny<<32: - return sbAny, true, 110 - // We'll always break after ParaSep due to SB4. - - default: - return -1, false, -1 - } -} - -// transitionSentenceBreakState determines the new state of the sentence break -// parser given the current state and the next code point. It also returns -// whether a sentence boundary was detected. If more than one code point is -// needed to determine the new state, the byte slice or the string starting -// after rune "r" can be used (whichever is not nil or empty) for further -// lookups. -func transitionSentenceBreakState(state int, r rune, b []byte, str string) (newState int, sentenceBreak bool) { - // Determine the property of the next character. - nextProperty := property(sentenceBreakCodePoints, r) - - // SB5 (Replacing Ignore Rules). - if nextProperty == prExtend || nextProperty == prFormat { - if state == sbParaSep || state == sbCR { - return sbAny, true // Make sure we don't apply SB5 to SB3 or SB4. - } - if state < 0 { - return sbAny, true // SB1. - } - return state, false - } - - // Find the applicable transition in the table. - var rule int - newState, sentenceBreak, rule = sbTransitions(state, nextProperty) - if newState < 0 { - // No specific transition found. Try the less specific ones. - anyPropState, anyPropProp, anyPropRule := sbTransitions(state, prAny) - anyStateState, anyStateProp, anyStateRule := sbTransitions(sbAny, nextProperty) - if anyPropState >= 0 && anyStateState >= 0 { - // Both apply. We'll use a mix (see comments for grTransitions). - newState, sentenceBreak, rule = anyStateState, anyStateProp, anyStateRule - if anyPropRule < anyStateRule { - sentenceBreak, rule = anyPropProp, anyPropRule - } - } else if anyPropState >= 0 { - // We only have a specific state. - newState, sentenceBreak, rule = anyPropState, anyPropProp, anyPropRule - // This branch will probably never be reached because okAnyState will - // always be true given the current transition map. But we keep it here - // for future modifications to the transition map where this may not be - // true anymore. - } else if anyStateState >= 0 { - // We only have a specific property. - newState, sentenceBreak, rule = anyStateState, anyStateProp, anyStateRule - } else { - // No known transition. SB999: Any × Any. - newState, sentenceBreak, rule = sbAny, false, 9990 - } - } - - // SB8. - if rule > 80 && (state == sbATerm || state == sbSB8Close || state == sbSB8Sp || state == sbSB7) { - // Check the right side of the rule. - var length int - for nextProperty != prOLetter && - nextProperty != prUpper && - nextProperty != prLower && - nextProperty != prSep && - nextProperty != prCR && - nextProperty != prLF && - nextProperty != prATerm && - nextProperty != prSTerm { - // Move on to the next rune. - if b != nil { // Byte slice version. - r, length = utf8.DecodeRune(b) - b = b[length:] - } else { // String version. - r, length = utf8.DecodeRuneInString(str) - str = str[length:] - } - if r == utf8.RuneError { - break - } - nextProperty = property(sentenceBreakCodePoints, r) - } - if nextProperty == prLower { - return sbLower, false - } - } - - return -} diff --git a/vendor/github.com/rivo/uniseg/step.go b/vendor/github.com/rivo/uniseg/step.go deleted file mode 100644 index 9b72c5e..0000000 --- a/vendor/github.com/rivo/uniseg/step.go +++ /dev/null @@ -1,242 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// The bit masks used to extract boundary information returned by [Step]. -const ( - MaskLine = 3 - MaskWord = 4 - MaskSentence = 8 -) - -// The number of bits to shift the boundary information returned by [Step] to -// obtain the monospace width of the grapheme cluster. -const ShiftWidth = 4 - -// The bit positions by which boundary flags are shifted by the [Step] function. -// These must correspond to the Mask constants. -const ( - shiftWord = 2 - shiftSentence = 3 - // shiftwWidth is ShiftWidth above. No mask as these are always the remaining bits. -) - -// The bit positions by which states are shifted by the [Step] function. These -// values must ensure state values defined for each of the boundary algorithms -// don't overlap (and that they all still fit in a single int). These must -// correspond to the Mask constants. -const ( - shiftWordState = 4 - shiftSentenceState = 9 - shiftLineState = 13 - shiftPropState = 21 // No mask as these are always the remaining bits. -) - -// The bit mask used to extract the state returned by the [Step] function, after -// shifting. These values must correspond to the shift constants. -const ( - maskGraphemeState = 0xf - maskWordState = 0x1f - maskSentenceState = 0xf - maskLineState = 0xff -) - -// Step returns the first grapheme cluster (user-perceived character) found in -// the given byte slice. It also returns information about the boundary between -// that grapheme cluster and the one following it as well as the monospace width -// of the grapheme cluster. There are three types of boundary information: word -// boundaries, sentence boundaries, and line breaks. This function is therefore -// a combination of [FirstGraphemeCluster], [FirstWord], [FirstSentence], and -// [FirstLineSegment]. -// -// The "boundaries" return value can be evaluated as follows: -// -// - boundaries&MaskWord != 0: The boundary is a word boundary. -// - boundaries&MaskWord == 0: The boundary is not a word boundary. -// - boundaries&MaskSentence != 0: The boundary is a sentence boundary. -// - boundaries&MaskSentence == 0: The boundary is not a sentence boundary. -// - boundaries&MaskLine == LineDontBreak: You must not break the line at the -// boundary. -// - boundaries&MaskLine == LineMustBreak: You must break the line at the -// boundary. -// - boundaries&MaskLine == LineCanBreak: You may or may not break the line at -// the boundary. -// - boundaries >> ShiftWidth: The width of the grapheme cluster for most -// monospace fonts where a value of 1 represents one character cell. -// -// This function can be called continuously to extract all grapheme clusters -// from a byte slice, as illustrated in the examples below. -// -// If you don't know which state to pass, for example when calling the function -// for the first time, you must pass -1. For consecutive calls, pass the state -// and rest slice returned by the previous call. -// -// The "rest" slice is the sub-slice of the original byte slice "b" starting -// after the last byte of the identified grapheme cluster. If the length of the -// "rest" slice is 0, the entire byte slice "b" has been processed. The -// "cluster" byte slice is the sub-slice of the input slice containing the -// first identified grapheme cluster. -// -// Given an empty byte slice "b", the function returns nil values. -// -// While slightly less convenient than using the Graphemes class, this function -// has much better performance and makes no allocations. It lends itself well to -// large byte slices. -// -// Note that in accordance with [UAX #14 LB3], the final segment will end with -// a mandatory line break (boundaries&MaskLine == LineMustBreak). You can choose -// to ignore this by checking if the length of the "rest" slice is 0 and calling -// [HasTrailingLineBreak] or [HasTrailingLineBreakInString] on the last rune. -// -// [UAX #14 LB3]: https://www.unicode.org/reports/tr14/#Algorithm -func Step(b []byte, state int) (cluster, rest []byte, boundaries int, newState int) { - // An empty byte slice returns nothing. - if len(b) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRune(b) - if len(b) <= length { // If we're already past the end, there is nothing else to parse. - var prop int - if state < 0 { - prop = propertyGraphemes(r) - } else { - prop = state >> shiftPropState - } - return b, nil, LineMustBreak | (1 << shiftWord) | (1 << shiftSentence) | (runeWidth(r, prop) << ShiftWidth), grAny | (wbAny << shiftWordState) | (sbAny << shiftSentenceState) | (lbAny << shiftLineState) | (prop << shiftPropState) - } - - // If we don't know the state, determine it now. - var graphemeState, wordState, sentenceState, lineState, firstProp int - remainder := b[length:] - if state < 0 { - graphemeState, firstProp, _ = transitionGraphemeState(state, r) - wordState, _ = transitionWordBreakState(state, r, remainder, "") - sentenceState, _ = transitionSentenceBreakState(state, r, remainder, "") - lineState, _ = transitionLineBreakState(state, r, remainder, "") - } else { - graphemeState = state & maskGraphemeState - wordState = (state >> shiftWordState) & maskWordState - sentenceState = (state >> shiftSentenceState) & maskSentenceState - lineState = (state >> shiftLineState) & maskLineState - firstProp = state >> shiftPropState - } - - // Transition until we find a grapheme cluster boundary. - width := runeWidth(r, firstProp) - for { - var ( - graphemeBoundary, wordBoundary, sentenceBoundary bool - lineBreak, prop int - ) - - r, l := utf8.DecodeRune(remainder) - remainder = b[length+l:] - - graphemeState, prop, graphemeBoundary = transitionGraphemeState(graphemeState, r) - wordState, wordBoundary = transitionWordBreakState(wordState, r, remainder, "") - sentenceState, sentenceBoundary = transitionSentenceBreakState(sentenceState, r, remainder, "") - lineState, lineBreak = transitionLineBreakState(lineState, r, remainder, "") - - if graphemeBoundary { - boundary := lineBreak | (width << ShiftWidth) - if wordBoundary { - boundary |= 1 << shiftWord - } - if sentenceBoundary { - boundary |= 1 << shiftSentence - } - return b[:length], b[length:], boundary, graphemeState | (wordState << shiftWordState) | (sentenceState << shiftSentenceState) | (lineState << shiftLineState) | (prop << shiftPropState) - } - - if firstProp == prExtendedPictographic { - if r == vs15 { - width = 1 - } else if r == vs16 { - width = 2 - } - } else if firstProp != prRegionalIndicator && firstProp != prL { - width += runeWidth(r, prop) - } - - length += l - if len(b) <= length { - return b, nil, LineMustBreak | (1 << shiftWord) | (1 << shiftSentence) | (width << ShiftWidth), grAny | (wbAny << shiftWordState) | (sbAny << shiftSentenceState) | (lbAny << shiftLineState) | (prop << shiftPropState) - } - } -} - -// StepString is like [Step] but its input and outputs are strings. -func StepString(str string, state int) (cluster, rest string, boundaries int, newState int) { - // An empty byte slice returns nothing. - if len(str) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRuneInString(str) - if len(str) <= length { // If we're already past the end, there is nothing else to parse. - prop := propertyGraphemes(r) - return str, "", LineMustBreak | (1 << shiftWord) | (1 << shiftSentence) | (runeWidth(r, prop) << ShiftWidth), grAny | (wbAny << shiftWordState) | (sbAny << shiftSentenceState) | (lbAny << shiftLineState) - } - - // If we don't know the state, determine it now. - var graphemeState, wordState, sentenceState, lineState, firstProp int - remainder := str[length:] - if state < 0 { - graphemeState, firstProp, _ = transitionGraphemeState(state, r) - wordState, _ = transitionWordBreakState(state, r, nil, remainder) - sentenceState, _ = transitionSentenceBreakState(state, r, nil, remainder) - lineState, _ = transitionLineBreakState(state, r, nil, remainder) - } else { - graphemeState = state & maskGraphemeState - wordState = (state >> shiftWordState) & maskWordState - sentenceState = (state >> shiftSentenceState) & maskSentenceState - lineState = (state >> shiftLineState) & maskLineState - firstProp = state >> shiftPropState - } - - // Transition until we find a grapheme cluster boundary. - width := runeWidth(r, firstProp) - for { - var ( - graphemeBoundary, wordBoundary, sentenceBoundary bool - lineBreak, prop int - ) - - r, l := utf8.DecodeRuneInString(remainder) - remainder = str[length+l:] - - graphemeState, prop, graphemeBoundary = transitionGraphemeState(graphemeState, r) - wordState, wordBoundary = transitionWordBreakState(wordState, r, nil, remainder) - sentenceState, sentenceBoundary = transitionSentenceBreakState(sentenceState, r, nil, remainder) - lineState, lineBreak = transitionLineBreakState(lineState, r, nil, remainder) - - if graphemeBoundary { - boundary := lineBreak | (width << ShiftWidth) - if wordBoundary { - boundary |= 1 << shiftWord - } - if sentenceBoundary { - boundary |= 1 << shiftSentence - } - return str[:length], str[length:], boundary, graphemeState | (wordState << shiftWordState) | (sentenceState << shiftSentenceState) | (lineState << shiftLineState) | (prop << shiftPropState) - } - - if firstProp == prExtendedPictographic { - if r == vs15 { - width = 1 - } else if r == vs16 { - width = 2 - } - } else if firstProp != prRegionalIndicator && firstProp != prL { - width += runeWidth(r, prop) - } - - length += l - if len(str) <= length { - return str, "", LineMustBreak | (1 << shiftWord) | (1 << shiftSentence) | (width << ShiftWidth), grAny | (wbAny << shiftWordState) | (sbAny << shiftSentenceState) | (lbAny << shiftLineState) | (prop << shiftPropState) - } - } -} diff --git a/vendor/github.com/rivo/uniseg/width.go b/vendor/github.com/rivo/uniseg/width.go deleted file mode 100644 index 975a9f1..0000000 --- a/vendor/github.com/rivo/uniseg/width.go +++ /dev/null @@ -1,61 +0,0 @@ -package uniseg - -// EastAsianAmbiguousWidth specifies the monospace width for East Asian -// characters classified as Ambiguous. The default is 1 but some rare fonts -// render them with a width of 2. -var EastAsianAmbiguousWidth = 1 - -// runeWidth returns the monospace width for the given rune. The provided -// grapheme property is a value mapped by the [graphemeCodePoints] table. -// -// Every rune has a width of 1, except for runes with the following properties -// (evaluated in this order): -// -// - Control, CR, LF, Extend, ZWJ: Width of 0 -// - \u2e3a, TWO-EM DASH: Width of 3 -// - \u2e3b, THREE-EM DASH: Width of 4 -// - East-Asian width Fullwidth and Wide: Width of 2 (Ambiguous and Neutral -// have a width of 1) -// - Regional Indicator: Width of 2 -// - Extended Pictographic: Width of 2, unless Emoji Presentation is "No". -func runeWidth(r rune, graphemeProperty int) int { - switch graphemeProperty { - case prControl, prCR, prLF, prExtend, prZWJ: - return 0 - case prRegionalIndicator: - return 2 - case prExtendedPictographic: - if property(emojiPresentation, r) == prEmojiPresentation { - return 2 - } - return 1 - } - - switch r { - case 0x2e3a: - return 3 - case 0x2e3b: - return 4 - } - - switch propertyEastAsianWidth(r) { - case prW, prF: - return 2 - case prA: - return EastAsianAmbiguousWidth - } - - return 1 -} - -// StringWidth returns the monospace width for the given string, that is, the -// number of same-size cells to be occupied by the string. -func StringWidth(s string) (width int) { - state := -1 - for len(s) > 0 { - var w int - _, s, w, state = FirstGraphemeClusterInString(s, state) - width += w - } - return -} diff --git a/vendor/github.com/rivo/uniseg/word.go b/vendor/github.com/rivo/uniseg/word.go deleted file mode 100644 index 34fba7f..0000000 --- a/vendor/github.com/rivo/uniseg/word.go +++ /dev/null @@ -1,89 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// FirstWord returns the first word found in the given byte slice according to -// the rules of [Unicode Standard Annex #29, Word Boundaries]. This function can -// be called continuously to extract all words from a byte slice, as illustrated -// in the example below. -// -// If you don't know the current state, for example when calling the function -// for the first time, you must pass -1. For consecutive calls, pass the state -// and rest slice returned by the previous call. -// -// The "rest" slice is the sub-slice of the original byte slice "b" starting -// after the last byte of the identified word. If the length of the "rest" slice -// is 0, the entire byte slice "b" has been processed. The "word" byte slice is -// the sub-slice of the input slice containing the identified word. -// -// Given an empty byte slice "b", the function returns nil values. -// -// [Unicode Standard Annex #29, Word Boundaries]: http://unicode.org/reports/tr29/#Word_Boundaries -func FirstWord(b []byte, state int) (word, rest []byte, newState int) { - // An empty byte slice returns nothing. - if len(b) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRune(b) - if len(b) <= length { // If we're already past the end, there is nothing else to parse. - return b, nil, wbAny - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionWordBreakState(state, r, b[length:], "") - } - - // Transition until we find a boundary. - var boundary bool - for { - r, l := utf8.DecodeRune(b[length:]) - state, boundary = transitionWordBreakState(state, r, b[length+l:], "") - - if boundary { - return b[:length], b[length:], state - } - - length += l - if len(b) <= length { - return b, nil, wbAny - } - } -} - -// FirstWordInString is like [FirstWord] but its input and outputs are strings. -func FirstWordInString(str string, state int) (word, rest string, newState int) { - // An empty byte slice returns nothing. - if len(str) == 0 { - return - } - - // Extract the first rune. - r, length := utf8.DecodeRuneInString(str) - if len(str) <= length { // If we're already past the end, there is nothing else to parse. - return str, "", wbAny - } - - // If we don't know the state, determine it now. - if state < 0 { - state, _ = transitionWordBreakState(state, r, nil, str[length:]) - } - - // Transition until we find a boundary. - var boundary bool - for { - r, l := utf8.DecodeRuneInString(str[length:]) - state, boundary = transitionWordBreakState(state, r, nil, str[length+l:]) - - if boundary { - return str[:length], str[length:], state - } - - length += l - if len(str) <= length { - return str, "", wbAny - } - } -} diff --git a/vendor/github.com/rivo/uniseg/wordproperties.go b/vendor/github.com/rivo/uniseg/wordproperties.go deleted file mode 100644 index 277ca10..0000000 --- a/vendor/github.com/rivo/uniseg/wordproperties.go +++ /dev/null @@ -1,1883 +0,0 @@ -// Code generated via go generate from gen_properties.go. DO NOT EDIT. - -package uniseg - -// workBreakCodePoints are taken from -// https://www.unicode.org/Public/15.0.0/ucd/auxiliary/WordBreakProperty.txt -// and -// https://unicode.org/Public/15.0.0/ucd/emoji/emoji-data.txt -// ("Extended_Pictographic" only) -// on September 5, 2023. See https://www.unicode.org/license.html for the Unicode -// license agreement. -var workBreakCodePoints = [][3]int{ - {0x000A, 0x000A, prLF}, // Cc - {0x000B, 0x000C, prNewline}, // Cc [2] .. - {0x000D, 0x000D, prCR}, // Cc - {0x0020, 0x0020, prWSegSpace}, // Zs SPACE - {0x0022, 0x0022, prDoubleQuote}, // Po QUOTATION MARK - {0x0027, 0x0027, prSingleQuote}, // Po APOSTROPHE - {0x002C, 0x002C, prMidNum}, // Po COMMA - {0x002E, 0x002E, prMidNumLet}, // Po FULL STOP - {0x0030, 0x0039, prNumeric}, // Nd [10] DIGIT ZERO..DIGIT NINE - {0x003A, 0x003A, prMidLetter}, // Po COLON - {0x003B, 0x003B, prMidNum}, // Po SEMICOLON - {0x0041, 0x005A, prALetter}, // L& [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z - {0x005F, 0x005F, prExtendNumLet}, // Pc LOW LINE - {0x0061, 0x007A, prALetter}, // L& [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z - {0x0085, 0x0085, prNewline}, // Cc - {0x00A9, 0x00A9, prExtendedPictographic}, // E0.6 [1] (©️) copyright - {0x00AA, 0x00AA, prALetter}, // Lo FEMININE ORDINAL INDICATOR - {0x00AD, 0x00AD, prFormat}, // Cf SOFT HYPHEN - {0x00AE, 0x00AE, prExtendedPictographic}, // E0.6 [1] (®️) registered - {0x00B5, 0x00B5, prALetter}, // L& MICRO SIGN - {0x00B7, 0x00B7, prMidLetter}, // Po MIDDLE DOT - {0x00BA, 0x00BA, prALetter}, // Lo MASCULINE ORDINAL INDICATOR - {0x00C0, 0x00D6, prALetter}, // L& [23] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER O WITH DIAERESIS - {0x00D8, 0x00F6, prALetter}, // L& [31] LATIN CAPITAL LETTER O WITH STROKE..LATIN SMALL LETTER O WITH DIAERESIS - {0x00F8, 0x01BA, prALetter}, // L& [195] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL - {0x01BB, 0x01BB, prALetter}, // Lo LATIN LETTER TWO WITH STROKE - {0x01BC, 0x01BF, prALetter}, // L& [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN - {0x01C0, 0x01C3, prALetter}, // Lo [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK - {0x01C4, 0x0293, prALetter}, // L& [208] LATIN CAPITAL LETTER DZ WITH CARON..LATIN SMALL LETTER EZH WITH CURL - {0x0294, 0x0294, prALetter}, // Lo LATIN LETTER GLOTTAL STOP - {0x0295, 0x02AF, prALetter}, // L& [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL - {0x02B0, 0x02C1, prALetter}, // Lm [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP - {0x02C2, 0x02C5, prALetter}, // Sk [4] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER DOWN ARROWHEAD - {0x02C6, 0x02D1, prALetter}, // Lm [12] MODIFIER LETTER CIRCUMFLEX ACCENT..MODIFIER LETTER HALF TRIANGULAR COLON - {0x02D2, 0x02D7, prALetter}, // Sk [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN - {0x02DE, 0x02DF, prALetter}, // Sk [2] MODIFIER LETTER RHOTIC HOOK..MODIFIER LETTER CROSS ACCENT - {0x02E0, 0x02E4, prALetter}, // Lm [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP - {0x02E5, 0x02EB, prALetter}, // Sk [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK - {0x02EC, 0x02EC, prALetter}, // Lm MODIFIER LETTER VOICING - {0x02ED, 0x02ED, prALetter}, // Sk MODIFIER LETTER UNASPIRATED - {0x02EE, 0x02EE, prALetter}, // Lm MODIFIER LETTER DOUBLE APOSTROPHE - {0x02EF, 0x02FF, prALetter}, // Sk [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW - {0x0300, 0x036F, prExtend}, // Mn [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X - {0x0370, 0x0373, prALetter}, // L& [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI - {0x0374, 0x0374, prALetter}, // Lm GREEK NUMERAL SIGN - {0x0376, 0x0377, prALetter}, // L& [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA - {0x037A, 0x037A, prALetter}, // Lm GREEK YPOGEGRAMMENI - {0x037B, 0x037D, prALetter}, // L& [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL - {0x037E, 0x037E, prMidNum}, // Po GREEK QUESTION MARK - {0x037F, 0x037F, prALetter}, // L& GREEK CAPITAL LETTER YOT - {0x0386, 0x0386, prALetter}, // L& GREEK CAPITAL LETTER ALPHA WITH TONOS - {0x0387, 0x0387, prMidLetter}, // Po GREEK ANO TELEIA - {0x0388, 0x038A, prALetter}, // L& [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS - {0x038C, 0x038C, prALetter}, // L& GREEK CAPITAL LETTER OMICRON WITH TONOS - {0x038E, 0x03A1, prALetter}, // L& [20] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK CAPITAL LETTER RHO - {0x03A3, 0x03F5, prALetter}, // L& [83] GREEK CAPITAL LETTER SIGMA..GREEK LUNATE EPSILON SYMBOL - {0x03F7, 0x0481, prALetter}, // L& [139] GREEK CAPITAL LETTER SHO..CYRILLIC SMALL LETTER KOPPA - {0x0483, 0x0487, prExtend}, // Mn [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE - {0x0488, 0x0489, prExtend}, // Me [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN - {0x048A, 0x052F, prALetter}, // L& [166] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER EL WITH DESCENDER - {0x0531, 0x0556, prALetter}, // L& [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH - {0x0559, 0x0559, prALetter}, // Lm ARMENIAN MODIFIER LETTER LEFT HALF RING - {0x055A, 0x055C, prALetter}, // Po [3] ARMENIAN APOSTROPHE..ARMENIAN EXCLAMATION MARK - {0x055E, 0x055E, prALetter}, // Po ARMENIAN QUESTION MARK - {0x055F, 0x055F, prMidLetter}, // Po ARMENIAN ABBREVIATION MARK - {0x0560, 0x0588, prALetter}, // L& [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE - {0x0589, 0x0589, prMidNum}, // Po ARMENIAN FULL STOP - {0x058A, 0x058A, prALetter}, // Pd ARMENIAN HYPHEN - {0x0591, 0x05BD, prExtend}, // Mn [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG - {0x05BF, 0x05BF, prExtend}, // Mn HEBREW POINT RAFE - {0x05C1, 0x05C2, prExtend}, // Mn [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT - {0x05C4, 0x05C5, prExtend}, // Mn [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT - {0x05C7, 0x05C7, prExtend}, // Mn HEBREW POINT QAMATS QATAN - {0x05D0, 0x05EA, prHebrewLetter}, // Lo [27] HEBREW LETTER ALEF..HEBREW LETTER TAV - {0x05EF, 0x05F2, prHebrewLetter}, // Lo [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD - {0x05F3, 0x05F3, prALetter}, // Po HEBREW PUNCTUATION GERESH - {0x05F4, 0x05F4, prMidLetter}, // Po HEBREW PUNCTUATION GERSHAYIM - {0x0600, 0x0605, prFormat}, // Cf [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE - {0x060C, 0x060D, prMidNum}, // Po [2] ARABIC COMMA..ARABIC DATE SEPARATOR - {0x0610, 0x061A, prExtend}, // Mn [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA - {0x061C, 0x061C, prFormat}, // Cf ARABIC LETTER MARK - {0x0620, 0x063F, prALetter}, // Lo [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE - {0x0640, 0x0640, prALetter}, // Lm ARABIC TATWEEL - {0x0641, 0x064A, prALetter}, // Lo [10] ARABIC LETTER FEH..ARABIC LETTER YEH - {0x064B, 0x065F, prExtend}, // Mn [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW - {0x0660, 0x0669, prNumeric}, // Nd [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE - {0x066B, 0x066B, prNumeric}, // Po ARABIC DECIMAL SEPARATOR - {0x066C, 0x066C, prMidNum}, // Po ARABIC THOUSANDS SEPARATOR - {0x066E, 0x066F, prALetter}, // Lo [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF - {0x0670, 0x0670, prExtend}, // Mn ARABIC LETTER SUPERSCRIPT ALEF - {0x0671, 0x06D3, prALetter}, // Lo [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE - {0x06D5, 0x06D5, prALetter}, // Lo ARABIC LETTER AE - {0x06D6, 0x06DC, prExtend}, // Mn [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN - {0x06DD, 0x06DD, prFormat}, // Cf ARABIC END OF AYAH - {0x06DF, 0x06E4, prExtend}, // Mn [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA - {0x06E5, 0x06E6, prALetter}, // Lm [2] ARABIC SMALL WAW..ARABIC SMALL YEH - {0x06E7, 0x06E8, prExtend}, // Mn [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON - {0x06EA, 0x06ED, prExtend}, // Mn [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM - {0x06EE, 0x06EF, prALetter}, // Lo [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V - {0x06F0, 0x06F9, prNumeric}, // Nd [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE - {0x06FA, 0x06FC, prALetter}, // Lo [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW - {0x06FF, 0x06FF, prALetter}, // Lo ARABIC LETTER HEH WITH INVERTED V - {0x070F, 0x070F, prFormat}, // Cf SYRIAC ABBREVIATION MARK - {0x0710, 0x0710, prALetter}, // Lo SYRIAC LETTER ALAPH - {0x0711, 0x0711, prExtend}, // Mn SYRIAC LETTER SUPERSCRIPT ALAPH - {0x0712, 0x072F, prALetter}, // Lo [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH - {0x0730, 0x074A, prExtend}, // Mn [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH - {0x074D, 0x07A5, prALetter}, // Lo [89] SYRIAC LETTER SOGDIAN ZHAIN..THAANA LETTER WAAVU - {0x07A6, 0x07B0, prExtend}, // Mn [11] THAANA ABAFILI..THAANA SUKUN - {0x07B1, 0x07B1, prALetter}, // Lo THAANA LETTER NAA - {0x07C0, 0x07C9, prNumeric}, // Nd [10] NKO DIGIT ZERO..NKO DIGIT NINE - {0x07CA, 0x07EA, prALetter}, // Lo [33] NKO LETTER A..NKO LETTER JONA RA - {0x07EB, 0x07F3, prExtend}, // Mn [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE - {0x07F4, 0x07F5, prALetter}, // Lm [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE - {0x07F8, 0x07F8, prMidNum}, // Po NKO COMMA - {0x07FA, 0x07FA, prALetter}, // Lm NKO LAJANYALAN - {0x07FD, 0x07FD, prExtend}, // Mn NKO DANTAYALAN - {0x0800, 0x0815, prALetter}, // Lo [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF - {0x0816, 0x0819, prExtend}, // Mn [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH - {0x081A, 0x081A, prALetter}, // Lm SAMARITAN MODIFIER LETTER EPENTHETIC YUT - {0x081B, 0x0823, prExtend}, // Mn [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A - {0x0824, 0x0824, prALetter}, // Lm SAMARITAN MODIFIER LETTER SHORT A - {0x0825, 0x0827, prExtend}, // Mn [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U - {0x0828, 0x0828, prALetter}, // Lm SAMARITAN MODIFIER LETTER I - {0x0829, 0x082D, prExtend}, // Mn [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA - {0x0840, 0x0858, prALetter}, // Lo [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN - {0x0859, 0x085B, prExtend}, // Mn [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK - {0x0860, 0x086A, prALetter}, // Lo [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA - {0x0870, 0x0887, prALetter}, // Lo [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT - {0x0889, 0x088E, prALetter}, // Lo [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL - {0x0890, 0x0891, prFormat}, // Cf [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE - {0x0898, 0x089F, prExtend}, // Mn [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA - {0x08A0, 0x08C8, prALetter}, // Lo [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF - {0x08C9, 0x08C9, prALetter}, // Lm ARABIC SMALL FARSI YEH - {0x08CA, 0x08E1, prExtend}, // Mn [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA - {0x08E2, 0x08E2, prFormat}, // Cf ARABIC DISPUTED END OF AYAH - {0x08E3, 0x0902, prExtend}, // Mn [32] ARABIC TURNED DAMMA BELOW..DEVANAGARI SIGN ANUSVARA - {0x0903, 0x0903, prExtend}, // Mc DEVANAGARI SIGN VISARGA - {0x0904, 0x0939, prALetter}, // Lo [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA - {0x093A, 0x093A, prExtend}, // Mn DEVANAGARI VOWEL SIGN OE - {0x093B, 0x093B, prExtend}, // Mc DEVANAGARI VOWEL SIGN OOE - {0x093C, 0x093C, prExtend}, // Mn DEVANAGARI SIGN NUKTA - {0x093D, 0x093D, prALetter}, // Lo DEVANAGARI SIGN AVAGRAHA - {0x093E, 0x0940, prExtend}, // Mc [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II - {0x0941, 0x0948, prExtend}, // Mn [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI - {0x0949, 0x094C, prExtend}, // Mc [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU - {0x094D, 0x094D, prExtend}, // Mn DEVANAGARI SIGN VIRAMA - {0x094E, 0x094F, prExtend}, // Mc [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW - {0x0950, 0x0950, prALetter}, // Lo DEVANAGARI OM - {0x0951, 0x0957, prExtend}, // Mn [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE - {0x0958, 0x0961, prALetter}, // Lo [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL - {0x0962, 0x0963, prExtend}, // Mn [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL - {0x0966, 0x096F, prNumeric}, // Nd [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE - {0x0971, 0x0971, prALetter}, // Lm DEVANAGARI SIGN HIGH SPACING DOT - {0x0972, 0x0980, prALetter}, // Lo [15] DEVANAGARI LETTER CANDRA A..BENGALI ANJI - {0x0981, 0x0981, prExtend}, // Mn BENGALI SIGN CANDRABINDU - {0x0982, 0x0983, prExtend}, // Mc [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA - {0x0985, 0x098C, prALetter}, // Lo [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L - {0x098F, 0x0990, prALetter}, // Lo [2] BENGALI LETTER E..BENGALI LETTER AI - {0x0993, 0x09A8, prALetter}, // Lo [22] BENGALI LETTER O..BENGALI LETTER NA - {0x09AA, 0x09B0, prALetter}, // Lo [7] BENGALI LETTER PA..BENGALI LETTER RA - {0x09B2, 0x09B2, prALetter}, // Lo BENGALI LETTER LA - {0x09B6, 0x09B9, prALetter}, // Lo [4] BENGALI LETTER SHA..BENGALI LETTER HA - {0x09BC, 0x09BC, prExtend}, // Mn BENGALI SIGN NUKTA - {0x09BD, 0x09BD, prALetter}, // Lo BENGALI SIGN AVAGRAHA - {0x09BE, 0x09C0, prExtend}, // Mc [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II - {0x09C1, 0x09C4, prExtend}, // Mn [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR - {0x09C7, 0x09C8, prExtend}, // Mc [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI - {0x09CB, 0x09CC, prExtend}, // Mc [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU - {0x09CD, 0x09CD, prExtend}, // Mn BENGALI SIGN VIRAMA - {0x09CE, 0x09CE, prALetter}, // Lo BENGALI LETTER KHANDA TA - {0x09D7, 0x09D7, prExtend}, // Mc BENGALI AU LENGTH MARK - {0x09DC, 0x09DD, prALetter}, // Lo [2] BENGALI LETTER RRA..BENGALI LETTER RHA - {0x09DF, 0x09E1, prALetter}, // Lo [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL - {0x09E2, 0x09E3, prExtend}, // Mn [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL - {0x09E6, 0x09EF, prNumeric}, // Nd [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE - {0x09F0, 0x09F1, prALetter}, // Lo [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL - {0x09FC, 0x09FC, prALetter}, // Lo BENGALI LETTER VEDIC ANUSVARA - {0x09FE, 0x09FE, prExtend}, // Mn BENGALI SANDHI MARK - {0x0A01, 0x0A02, prExtend}, // Mn [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI - {0x0A03, 0x0A03, prExtend}, // Mc GURMUKHI SIGN VISARGA - {0x0A05, 0x0A0A, prALetter}, // Lo [6] GURMUKHI LETTER A..GURMUKHI LETTER UU - {0x0A0F, 0x0A10, prALetter}, // Lo [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI - {0x0A13, 0x0A28, prALetter}, // Lo [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA - {0x0A2A, 0x0A30, prALetter}, // Lo [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA - {0x0A32, 0x0A33, prALetter}, // Lo [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA - {0x0A35, 0x0A36, prALetter}, // Lo [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA - {0x0A38, 0x0A39, prALetter}, // Lo [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA - {0x0A3C, 0x0A3C, prExtend}, // Mn GURMUKHI SIGN NUKTA - {0x0A3E, 0x0A40, prExtend}, // Mc [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II - {0x0A41, 0x0A42, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU - {0x0A47, 0x0A48, prExtend}, // Mn [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI - {0x0A4B, 0x0A4D, prExtend}, // Mn [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA - {0x0A51, 0x0A51, prExtend}, // Mn GURMUKHI SIGN UDAAT - {0x0A59, 0x0A5C, prALetter}, // Lo [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA - {0x0A5E, 0x0A5E, prALetter}, // Lo GURMUKHI LETTER FA - {0x0A66, 0x0A6F, prNumeric}, // Nd [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE - {0x0A70, 0x0A71, prExtend}, // Mn [2] GURMUKHI TIPPI..GURMUKHI ADDAK - {0x0A72, 0x0A74, prALetter}, // Lo [3] GURMUKHI IRI..GURMUKHI EK ONKAR - {0x0A75, 0x0A75, prExtend}, // Mn GURMUKHI SIGN YAKASH - {0x0A81, 0x0A82, prExtend}, // Mn [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA - {0x0A83, 0x0A83, prExtend}, // Mc GUJARATI SIGN VISARGA - {0x0A85, 0x0A8D, prALetter}, // Lo [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E - {0x0A8F, 0x0A91, prALetter}, // Lo [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O - {0x0A93, 0x0AA8, prALetter}, // Lo [22] GUJARATI LETTER O..GUJARATI LETTER NA - {0x0AAA, 0x0AB0, prALetter}, // Lo [7] GUJARATI LETTER PA..GUJARATI LETTER RA - {0x0AB2, 0x0AB3, prALetter}, // Lo [2] GUJARATI LETTER LA..GUJARATI LETTER LLA - {0x0AB5, 0x0AB9, prALetter}, // Lo [5] GUJARATI LETTER VA..GUJARATI LETTER HA - {0x0ABC, 0x0ABC, prExtend}, // Mn GUJARATI SIGN NUKTA - {0x0ABD, 0x0ABD, prALetter}, // Lo GUJARATI SIGN AVAGRAHA - {0x0ABE, 0x0AC0, prExtend}, // Mc [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II - {0x0AC1, 0x0AC5, prExtend}, // Mn [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E - {0x0AC7, 0x0AC8, prExtend}, // Mn [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI - {0x0AC9, 0x0AC9, prExtend}, // Mc GUJARATI VOWEL SIGN CANDRA O - {0x0ACB, 0x0ACC, prExtend}, // Mc [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU - {0x0ACD, 0x0ACD, prExtend}, // Mn GUJARATI SIGN VIRAMA - {0x0AD0, 0x0AD0, prALetter}, // Lo GUJARATI OM - {0x0AE0, 0x0AE1, prALetter}, // Lo [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL - {0x0AE2, 0x0AE3, prExtend}, // Mn [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL - {0x0AE6, 0x0AEF, prNumeric}, // Nd [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE - {0x0AF9, 0x0AF9, prALetter}, // Lo GUJARATI LETTER ZHA - {0x0AFA, 0x0AFF, prExtend}, // Mn [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE - {0x0B01, 0x0B01, prExtend}, // Mn ORIYA SIGN CANDRABINDU - {0x0B02, 0x0B03, prExtend}, // Mc [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA - {0x0B05, 0x0B0C, prALetter}, // Lo [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L - {0x0B0F, 0x0B10, prALetter}, // Lo [2] ORIYA LETTER E..ORIYA LETTER AI - {0x0B13, 0x0B28, prALetter}, // Lo [22] ORIYA LETTER O..ORIYA LETTER NA - {0x0B2A, 0x0B30, prALetter}, // Lo [7] ORIYA LETTER PA..ORIYA LETTER RA - {0x0B32, 0x0B33, prALetter}, // Lo [2] ORIYA LETTER LA..ORIYA LETTER LLA - {0x0B35, 0x0B39, prALetter}, // Lo [5] ORIYA LETTER VA..ORIYA LETTER HA - {0x0B3C, 0x0B3C, prExtend}, // Mn ORIYA SIGN NUKTA - {0x0B3D, 0x0B3D, prALetter}, // Lo ORIYA SIGN AVAGRAHA - {0x0B3E, 0x0B3E, prExtend}, // Mc ORIYA VOWEL SIGN AA - {0x0B3F, 0x0B3F, prExtend}, // Mn ORIYA VOWEL SIGN I - {0x0B40, 0x0B40, prExtend}, // Mc ORIYA VOWEL SIGN II - {0x0B41, 0x0B44, prExtend}, // Mn [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR - {0x0B47, 0x0B48, prExtend}, // Mc [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI - {0x0B4B, 0x0B4C, prExtend}, // Mc [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU - {0x0B4D, 0x0B4D, prExtend}, // Mn ORIYA SIGN VIRAMA - {0x0B55, 0x0B56, prExtend}, // Mn [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK - {0x0B57, 0x0B57, prExtend}, // Mc ORIYA AU LENGTH MARK - {0x0B5C, 0x0B5D, prALetter}, // Lo [2] ORIYA LETTER RRA..ORIYA LETTER RHA - {0x0B5F, 0x0B61, prALetter}, // Lo [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL - {0x0B62, 0x0B63, prExtend}, // Mn [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL - {0x0B66, 0x0B6F, prNumeric}, // Nd [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE - {0x0B71, 0x0B71, prALetter}, // Lo ORIYA LETTER WA - {0x0B82, 0x0B82, prExtend}, // Mn TAMIL SIGN ANUSVARA - {0x0B83, 0x0B83, prALetter}, // Lo TAMIL SIGN VISARGA - {0x0B85, 0x0B8A, prALetter}, // Lo [6] TAMIL LETTER A..TAMIL LETTER UU - {0x0B8E, 0x0B90, prALetter}, // Lo [3] TAMIL LETTER E..TAMIL LETTER AI - {0x0B92, 0x0B95, prALetter}, // Lo [4] TAMIL LETTER O..TAMIL LETTER KA - {0x0B99, 0x0B9A, prALetter}, // Lo [2] TAMIL LETTER NGA..TAMIL LETTER CA - {0x0B9C, 0x0B9C, prALetter}, // Lo TAMIL LETTER JA - {0x0B9E, 0x0B9F, prALetter}, // Lo [2] TAMIL LETTER NYA..TAMIL LETTER TTA - {0x0BA3, 0x0BA4, prALetter}, // Lo [2] TAMIL LETTER NNA..TAMIL LETTER TA - {0x0BA8, 0x0BAA, prALetter}, // Lo [3] TAMIL LETTER NA..TAMIL LETTER PA - {0x0BAE, 0x0BB9, prALetter}, // Lo [12] TAMIL LETTER MA..TAMIL LETTER HA - {0x0BBE, 0x0BBF, prExtend}, // Mc [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I - {0x0BC0, 0x0BC0, prExtend}, // Mn TAMIL VOWEL SIGN II - {0x0BC1, 0x0BC2, prExtend}, // Mc [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU - {0x0BC6, 0x0BC8, prExtend}, // Mc [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI - {0x0BCA, 0x0BCC, prExtend}, // Mc [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU - {0x0BCD, 0x0BCD, prExtend}, // Mn TAMIL SIGN VIRAMA - {0x0BD0, 0x0BD0, prALetter}, // Lo TAMIL OM - {0x0BD7, 0x0BD7, prExtend}, // Mc TAMIL AU LENGTH MARK - {0x0BE6, 0x0BEF, prNumeric}, // Nd [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE - {0x0C00, 0x0C00, prExtend}, // Mn TELUGU SIGN COMBINING CANDRABINDU ABOVE - {0x0C01, 0x0C03, prExtend}, // Mc [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA - {0x0C04, 0x0C04, prExtend}, // Mn TELUGU SIGN COMBINING ANUSVARA ABOVE - {0x0C05, 0x0C0C, prALetter}, // Lo [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L - {0x0C0E, 0x0C10, prALetter}, // Lo [3] TELUGU LETTER E..TELUGU LETTER AI - {0x0C12, 0x0C28, prALetter}, // Lo [23] TELUGU LETTER O..TELUGU LETTER NA - {0x0C2A, 0x0C39, prALetter}, // Lo [16] TELUGU LETTER PA..TELUGU LETTER HA - {0x0C3C, 0x0C3C, prExtend}, // Mn TELUGU SIGN NUKTA - {0x0C3D, 0x0C3D, prALetter}, // Lo TELUGU SIGN AVAGRAHA - {0x0C3E, 0x0C40, prExtend}, // Mn [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II - {0x0C41, 0x0C44, prExtend}, // Mc [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR - {0x0C46, 0x0C48, prExtend}, // Mn [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI - {0x0C4A, 0x0C4D, prExtend}, // Mn [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA - {0x0C55, 0x0C56, prExtend}, // Mn [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK - {0x0C58, 0x0C5A, prALetter}, // Lo [3] TELUGU LETTER TSA..TELUGU LETTER RRRA - {0x0C5D, 0x0C5D, prALetter}, // Lo TELUGU LETTER NAKAARA POLLU - {0x0C60, 0x0C61, prALetter}, // Lo [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL - {0x0C62, 0x0C63, prExtend}, // Mn [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL - {0x0C66, 0x0C6F, prNumeric}, // Nd [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE - {0x0C80, 0x0C80, prALetter}, // Lo KANNADA SIGN SPACING CANDRABINDU - {0x0C81, 0x0C81, prExtend}, // Mn KANNADA SIGN CANDRABINDU - {0x0C82, 0x0C83, prExtend}, // Mc [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA - {0x0C85, 0x0C8C, prALetter}, // Lo [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L - {0x0C8E, 0x0C90, prALetter}, // Lo [3] KANNADA LETTER E..KANNADA LETTER AI - {0x0C92, 0x0CA8, prALetter}, // Lo [23] KANNADA LETTER O..KANNADA LETTER NA - {0x0CAA, 0x0CB3, prALetter}, // Lo [10] KANNADA LETTER PA..KANNADA LETTER LLA - {0x0CB5, 0x0CB9, prALetter}, // Lo [5] KANNADA LETTER VA..KANNADA LETTER HA - {0x0CBC, 0x0CBC, prExtend}, // Mn KANNADA SIGN NUKTA - {0x0CBD, 0x0CBD, prALetter}, // Lo KANNADA SIGN AVAGRAHA - {0x0CBE, 0x0CBE, prExtend}, // Mc KANNADA VOWEL SIGN AA - {0x0CBF, 0x0CBF, prExtend}, // Mn KANNADA VOWEL SIGN I - {0x0CC0, 0x0CC4, prExtend}, // Mc [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR - {0x0CC6, 0x0CC6, prExtend}, // Mn KANNADA VOWEL SIGN E - {0x0CC7, 0x0CC8, prExtend}, // Mc [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI - {0x0CCA, 0x0CCB, prExtend}, // Mc [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO - {0x0CCC, 0x0CCD, prExtend}, // Mn [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA - {0x0CD5, 0x0CD6, prExtend}, // Mc [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK - {0x0CDD, 0x0CDE, prALetter}, // Lo [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA - {0x0CE0, 0x0CE1, prALetter}, // Lo [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL - {0x0CE2, 0x0CE3, prExtend}, // Mn [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL - {0x0CE6, 0x0CEF, prNumeric}, // Nd [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE - {0x0CF1, 0x0CF2, prALetter}, // Lo [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA - {0x0CF3, 0x0CF3, prExtend}, // Mc KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT - {0x0D00, 0x0D01, prExtend}, // Mn [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU - {0x0D02, 0x0D03, prExtend}, // Mc [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA - {0x0D04, 0x0D0C, prALetter}, // Lo [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L - {0x0D0E, 0x0D10, prALetter}, // Lo [3] MALAYALAM LETTER E..MALAYALAM LETTER AI - {0x0D12, 0x0D3A, prALetter}, // Lo [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA - {0x0D3B, 0x0D3C, prExtend}, // Mn [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA - {0x0D3D, 0x0D3D, prALetter}, // Lo MALAYALAM SIGN AVAGRAHA - {0x0D3E, 0x0D40, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II - {0x0D41, 0x0D44, prExtend}, // Mn [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR - {0x0D46, 0x0D48, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI - {0x0D4A, 0x0D4C, prExtend}, // Mc [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU - {0x0D4D, 0x0D4D, prExtend}, // Mn MALAYALAM SIGN VIRAMA - {0x0D4E, 0x0D4E, prALetter}, // Lo MALAYALAM LETTER DOT REPH - {0x0D54, 0x0D56, prALetter}, // Lo [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL - {0x0D57, 0x0D57, prExtend}, // Mc MALAYALAM AU LENGTH MARK - {0x0D5F, 0x0D61, prALetter}, // Lo [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL - {0x0D62, 0x0D63, prExtend}, // Mn [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL - {0x0D66, 0x0D6F, prNumeric}, // Nd [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE - {0x0D7A, 0x0D7F, prALetter}, // Lo [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K - {0x0D81, 0x0D81, prExtend}, // Mn SINHALA SIGN CANDRABINDU - {0x0D82, 0x0D83, prExtend}, // Mc [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA - {0x0D85, 0x0D96, prALetter}, // Lo [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA - {0x0D9A, 0x0DB1, prALetter}, // Lo [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA - {0x0DB3, 0x0DBB, prALetter}, // Lo [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA - {0x0DBD, 0x0DBD, prALetter}, // Lo SINHALA LETTER DANTAJA LAYANNA - {0x0DC0, 0x0DC6, prALetter}, // Lo [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA - {0x0DCA, 0x0DCA, prExtend}, // Mn SINHALA SIGN AL-LAKUNA - {0x0DCF, 0x0DD1, prExtend}, // Mc [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA - {0x0DD2, 0x0DD4, prExtend}, // Mn [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA - {0x0DD6, 0x0DD6, prExtend}, // Mn SINHALA VOWEL SIGN DIGA PAA-PILLA - {0x0DD8, 0x0DDF, prExtend}, // Mc [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA - {0x0DE6, 0x0DEF, prNumeric}, // Nd [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE - {0x0DF2, 0x0DF3, prExtend}, // Mc [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA - {0x0E31, 0x0E31, prExtend}, // Mn THAI CHARACTER MAI HAN-AKAT - {0x0E34, 0x0E3A, prExtend}, // Mn [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU - {0x0E47, 0x0E4E, prExtend}, // Mn [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN - {0x0E50, 0x0E59, prNumeric}, // Nd [10] THAI DIGIT ZERO..THAI DIGIT NINE - {0x0EB1, 0x0EB1, prExtend}, // Mn LAO VOWEL SIGN MAI KAN - {0x0EB4, 0x0EBC, prExtend}, // Mn [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO - {0x0EC8, 0x0ECE, prExtend}, // Mn [7] LAO TONE MAI EK..LAO YAMAKKAN - {0x0ED0, 0x0ED9, prNumeric}, // Nd [10] LAO DIGIT ZERO..LAO DIGIT NINE - {0x0F00, 0x0F00, prALetter}, // Lo TIBETAN SYLLABLE OM - {0x0F18, 0x0F19, prExtend}, // Mn [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS - {0x0F20, 0x0F29, prNumeric}, // Nd [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE - {0x0F35, 0x0F35, prExtend}, // Mn TIBETAN MARK NGAS BZUNG NYI ZLA - {0x0F37, 0x0F37, prExtend}, // Mn TIBETAN MARK NGAS BZUNG SGOR RTAGS - {0x0F39, 0x0F39, prExtend}, // Mn TIBETAN MARK TSA -PHRU - {0x0F3E, 0x0F3F, prExtend}, // Mc [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES - {0x0F40, 0x0F47, prALetter}, // Lo [8] TIBETAN LETTER KA..TIBETAN LETTER JA - {0x0F49, 0x0F6C, prALetter}, // Lo [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA - {0x0F71, 0x0F7E, prExtend}, // Mn [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO - {0x0F7F, 0x0F7F, prExtend}, // Mc TIBETAN SIGN RNAM BCAD - {0x0F80, 0x0F84, prExtend}, // Mn [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA - {0x0F86, 0x0F87, prExtend}, // Mn [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS - {0x0F88, 0x0F8C, prALetter}, // Lo [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN - {0x0F8D, 0x0F97, prExtend}, // Mn [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA - {0x0F99, 0x0FBC, prExtend}, // Mn [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA - {0x0FC6, 0x0FC6, prExtend}, // Mn TIBETAN SYMBOL PADMA GDAN - {0x102B, 0x102C, prExtend}, // Mc [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA - {0x102D, 0x1030, prExtend}, // Mn [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU - {0x1031, 0x1031, prExtend}, // Mc MYANMAR VOWEL SIGN E - {0x1032, 0x1037, prExtend}, // Mn [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW - {0x1038, 0x1038, prExtend}, // Mc MYANMAR SIGN VISARGA - {0x1039, 0x103A, prExtend}, // Mn [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT - {0x103B, 0x103C, prExtend}, // Mc [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA - {0x103D, 0x103E, prExtend}, // Mn [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA - {0x1040, 0x1049, prNumeric}, // Nd [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE - {0x1056, 0x1057, prExtend}, // Mc [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR - {0x1058, 0x1059, prExtend}, // Mn [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL - {0x105E, 0x1060, prExtend}, // Mn [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA - {0x1062, 0x1064, prExtend}, // Mc [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO - {0x1067, 0x106D, prExtend}, // Mc [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5 - {0x1071, 0x1074, prExtend}, // Mn [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE - {0x1082, 0x1082, prExtend}, // Mn MYANMAR CONSONANT SIGN SHAN MEDIAL WA - {0x1083, 0x1084, prExtend}, // Mc [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E - {0x1085, 0x1086, prExtend}, // Mn [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y - {0x1087, 0x108C, prExtend}, // Mc [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3 - {0x108D, 0x108D, prExtend}, // Mn MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE - {0x108F, 0x108F, prExtend}, // Mc MYANMAR SIGN RUMAI PALAUNG TONE-5 - {0x1090, 0x1099, prNumeric}, // Nd [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE - {0x109A, 0x109C, prExtend}, // Mc [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A - {0x109D, 0x109D, prExtend}, // Mn MYANMAR VOWEL SIGN AITON AI - {0x10A0, 0x10C5, prALetter}, // L& [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE - {0x10C7, 0x10C7, prALetter}, // L& GEORGIAN CAPITAL LETTER YN - {0x10CD, 0x10CD, prALetter}, // L& GEORGIAN CAPITAL LETTER AEN - {0x10D0, 0x10FA, prALetter}, // L& [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN - {0x10FC, 0x10FC, prALetter}, // Lm MODIFIER LETTER GEORGIAN NAR - {0x10FD, 0x10FF, prALetter}, // L& [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN - {0x1100, 0x1248, prALetter}, // Lo [329] HANGUL CHOSEONG KIYEOK..ETHIOPIC SYLLABLE QWA - {0x124A, 0x124D, prALetter}, // Lo [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE - {0x1250, 0x1256, prALetter}, // Lo [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO - {0x1258, 0x1258, prALetter}, // Lo ETHIOPIC SYLLABLE QHWA - {0x125A, 0x125D, prALetter}, // Lo [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE - {0x1260, 0x1288, prALetter}, // Lo [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA - {0x128A, 0x128D, prALetter}, // Lo [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE - {0x1290, 0x12B0, prALetter}, // Lo [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA - {0x12B2, 0x12B5, prALetter}, // Lo [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE - {0x12B8, 0x12BE, prALetter}, // Lo [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO - {0x12C0, 0x12C0, prALetter}, // Lo ETHIOPIC SYLLABLE KXWA - {0x12C2, 0x12C5, prALetter}, // Lo [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE - {0x12C8, 0x12D6, prALetter}, // Lo [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O - {0x12D8, 0x1310, prALetter}, // Lo [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA - {0x1312, 0x1315, prALetter}, // Lo [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE - {0x1318, 0x135A, prALetter}, // Lo [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA - {0x135D, 0x135F, prExtend}, // Mn [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK - {0x1380, 0x138F, prALetter}, // Lo [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE - {0x13A0, 0x13F5, prALetter}, // L& [86] CHEROKEE LETTER A..CHEROKEE LETTER MV - {0x13F8, 0x13FD, prALetter}, // L& [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV - {0x1401, 0x166C, prALetter}, // Lo [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA - {0x166F, 0x167F, prALetter}, // Lo [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W - {0x1680, 0x1680, prWSegSpace}, // Zs OGHAM SPACE MARK - {0x1681, 0x169A, prALetter}, // Lo [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH - {0x16A0, 0x16EA, prALetter}, // Lo [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X - {0x16EE, 0x16F0, prALetter}, // Nl [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL - {0x16F1, 0x16F8, prALetter}, // Lo [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC - {0x1700, 0x1711, prALetter}, // Lo [18] TAGALOG LETTER A..TAGALOG LETTER HA - {0x1712, 0x1714, prExtend}, // Mn [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA - {0x1715, 0x1715, prExtend}, // Mc TAGALOG SIGN PAMUDPOD - {0x171F, 0x1731, prALetter}, // Lo [19] TAGALOG LETTER ARCHAIC RA..HANUNOO LETTER HA - {0x1732, 0x1733, prExtend}, // Mn [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U - {0x1734, 0x1734, prExtend}, // Mc HANUNOO SIGN PAMUDPOD - {0x1740, 0x1751, prALetter}, // Lo [18] BUHID LETTER A..BUHID LETTER HA - {0x1752, 0x1753, prExtend}, // Mn [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U - {0x1760, 0x176C, prALetter}, // Lo [13] TAGBANWA LETTER A..TAGBANWA LETTER YA - {0x176E, 0x1770, prALetter}, // Lo [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA - {0x1772, 0x1773, prExtend}, // Mn [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U - {0x17B4, 0x17B5, prExtend}, // Mn [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA - {0x17B6, 0x17B6, prExtend}, // Mc KHMER VOWEL SIGN AA - {0x17B7, 0x17BD, prExtend}, // Mn [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA - {0x17BE, 0x17C5, prExtend}, // Mc [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU - {0x17C6, 0x17C6, prExtend}, // Mn KHMER SIGN NIKAHIT - {0x17C7, 0x17C8, prExtend}, // Mc [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU - {0x17C9, 0x17D3, prExtend}, // Mn [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT - {0x17DD, 0x17DD, prExtend}, // Mn KHMER SIGN ATTHACAN - {0x17E0, 0x17E9, prNumeric}, // Nd [10] KHMER DIGIT ZERO..KHMER DIGIT NINE - {0x180B, 0x180D, prExtend}, // Mn [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE - {0x180E, 0x180E, prFormat}, // Cf MONGOLIAN VOWEL SEPARATOR - {0x180F, 0x180F, prExtend}, // Mn MONGOLIAN FREE VARIATION SELECTOR FOUR - {0x1810, 0x1819, prNumeric}, // Nd [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE - {0x1820, 0x1842, prALetter}, // Lo [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI - {0x1843, 0x1843, prALetter}, // Lm MONGOLIAN LETTER TODO LONG VOWEL SIGN - {0x1844, 0x1878, prALetter}, // Lo [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS - {0x1880, 0x1884, prALetter}, // Lo [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA - {0x1885, 0x1886, prExtend}, // Mn [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA - {0x1887, 0x18A8, prALetter}, // Lo [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA - {0x18A9, 0x18A9, prExtend}, // Mn MONGOLIAN LETTER ALI GALI DAGALGA - {0x18AA, 0x18AA, prALetter}, // Lo MONGOLIAN LETTER MANCHU ALI GALI LHA - {0x18B0, 0x18F5, prALetter}, // Lo [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S - {0x1900, 0x191E, prALetter}, // Lo [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA - {0x1920, 0x1922, prExtend}, // Mn [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U - {0x1923, 0x1926, prExtend}, // Mc [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU - {0x1927, 0x1928, prExtend}, // Mn [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O - {0x1929, 0x192B, prExtend}, // Mc [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA - {0x1930, 0x1931, prExtend}, // Mc [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA - {0x1932, 0x1932, prExtend}, // Mn LIMBU SMALL LETTER ANUSVARA - {0x1933, 0x1938, prExtend}, // Mc [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA - {0x1939, 0x193B, prExtend}, // Mn [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I - {0x1946, 0x194F, prNumeric}, // Nd [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE - {0x19D0, 0x19D9, prNumeric}, // Nd [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE - {0x1A00, 0x1A16, prALetter}, // Lo [23] BUGINESE LETTER KA..BUGINESE LETTER HA - {0x1A17, 0x1A18, prExtend}, // Mn [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U - {0x1A19, 0x1A1A, prExtend}, // Mc [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O - {0x1A1B, 0x1A1B, prExtend}, // Mn BUGINESE VOWEL SIGN AE - {0x1A55, 0x1A55, prExtend}, // Mc TAI THAM CONSONANT SIGN MEDIAL RA - {0x1A56, 0x1A56, prExtend}, // Mn TAI THAM CONSONANT SIGN MEDIAL LA - {0x1A57, 0x1A57, prExtend}, // Mc TAI THAM CONSONANT SIGN LA TANG LAI - {0x1A58, 0x1A5E, prExtend}, // Mn [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA - {0x1A60, 0x1A60, prExtend}, // Mn TAI THAM SIGN SAKOT - {0x1A61, 0x1A61, prExtend}, // Mc TAI THAM VOWEL SIGN A - {0x1A62, 0x1A62, prExtend}, // Mn TAI THAM VOWEL SIGN MAI SAT - {0x1A63, 0x1A64, prExtend}, // Mc [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA - {0x1A65, 0x1A6C, prExtend}, // Mn [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW - {0x1A6D, 0x1A72, prExtend}, // Mc [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI - {0x1A73, 0x1A7C, prExtend}, // Mn [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN - {0x1A7F, 0x1A7F, prExtend}, // Mn TAI THAM COMBINING CRYPTOGRAMMIC DOT - {0x1A80, 0x1A89, prNumeric}, // Nd [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE - {0x1A90, 0x1A99, prNumeric}, // Nd [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE - {0x1AB0, 0x1ABD, prExtend}, // Mn [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW - {0x1ABE, 0x1ABE, prExtend}, // Me COMBINING PARENTHESES OVERLAY - {0x1ABF, 0x1ACE, prExtend}, // Mn [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T - {0x1B00, 0x1B03, prExtend}, // Mn [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG - {0x1B04, 0x1B04, prExtend}, // Mc BALINESE SIGN BISAH - {0x1B05, 0x1B33, prALetter}, // Lo [47] BALINESE LETTER AKARA..BALINESE LETTER HA - {0x1B34, 0x1B34, prExtend}, // Mn BALINESE SIGN REREKAN - {0x1B35, 0x1B35, prExtend}, // Mc BALINESE VOWEL SIGN TEDUNG - {0x1B36, 0x1B3A, prExtend}, // Mn [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA - {0x1B3B, 0x1B3B, prExtend}, // Mc BALINESE VOWEL SIGN RA REPA TEDUNG - {0x1B3C, 0x1B3C, prExtend}, // Mn BALINESE VOWEL SIGN LA LENGA - {0x1B3D, 0x1B41, prExtend}, // Mc [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG - {0x1B42, 0x1B42, prExtend}, // Mn BALINESE VOWEL SIGN PEPET - {0x1B43, 0x1B44, prExtend}, // Mc [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG - {0x1B45, 0x1B4C, prALetter}, // Lo [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA - {0x1B50, 0x1B59, prNumeric}, // Nd [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE - {0x1B6B, 0x1B73, prExtend}, // Mn [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG - {0x1B80, 0x1B81, prExtend}, // Mn [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR - {0x1B82, 0x1B82, prExtend}, // Mc SUNDANESE SIGN PANGWISAD - {0x1B83, 0x1BA0, prALetter}, // Lo [30] SUNDANESE LETTER A..SUNDANESE LETTER HA - {0x1BA1, 0x1BA1, prExtend}, // Mc SUNDANESE CONSONANT SIGN PAMINGKAL - {0x1BA2, 0x1BA5, prExtend}, // Mn [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU - {0x1BA6, 0x1BA7, prExtend}, // Mc [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG - {0x1BA8, 0x1BA9, prExtend}, // Mn [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG - {0x1BAA, 0x1BAA, prExtend}, // Mc SUNDANESE SIGN PAMAAEH - {0x1BAB, 0x1BAD, prExtend}, // Mn [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA - {0x1BAE, 0x1BAF, prALetter}, // Lo [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA - {0x1BB0, 0x1BB9, prNumeric}, // Nd [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE - {0x1BBA, 0x1BE5, prALetter}, // Lo [44] SUNDANESE AVAGRAHA..BATAK LETTER U - {0x1BE6, 0x1BE6, prExtend}, // Mn BATAK SIGN TOMPI - {0x1BE7, 0x1BE7, prExtend}, // Mc BATAK VOWEL SIGN E - {0x1BE8, 0x1BE9, prExtend}, // Mn [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE - {0x1BEA, 0x1BEC, prExtend}, // Mc [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O - {0x1BED, 0x1BED, prExtend}, // Mn BATAK VOWEL SIGN KARO O - {0x1BEE, 0x1BEE, prExtend}, // Mc BATAK VOWEL SIGN U - {0x1BEF, 0x1BF1, prExtend}, // Mn [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H - {0x1BF2, 0x1BF3, prExtend}, // Mc [2] BATAK PANGOLAT..BATAK PANONGONAN - {0x1C00, 0x1C23, prALetter}, // Lo [36] LEPCHA LETTER KA..LEPCHA LETTER A - {0x1C24, 0x1C2B, prExtend}, // Mc [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU - {0x1C2C, 0x1C33, prExtend}, // Mn [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T - {0x1C34, 0x1C35, prExtend}, // Mc [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG - {0x1C36, 0x1C37, prExtend}, // Mn [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA - {0x1C40, 0x1C49, prNumeric}, // Nd [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE - {0x1C4D, 0x1C4F, prALetter}, // Lo [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA - {0x1C50, 0x1C59, prNumeric}, // Nd [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE - {0x1C5A, 0x1C77, prALetter}, // Lo [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH - {0x1C78, 0x1C7D, prALetter}, // Lm [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD - {0x1C80, 0x1C88, prALetter}, // L& [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK - {0x1C90, 0x1CBA, prALetter}, // L& [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN - {0x1CBD, 0x1CBF, prALetter}, // L& [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN - {0x1CD0, 0x1CD2, prExtend}, // Mn [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA - {0x1CD4, 0x1CE0, prExtend}, // Mn [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA - {0x1CE1, 0x1CE1, prExtend}, // Mc VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA - {0x1CE2, 0x1CE8, prExtend}, // Mn [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL - {0x1CE9, 0x1CEC, prALetter}, // Lo [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL - {0x1CED, 0x1CED, prExtend}, // Mn VEDIC SIGN TIRYAK - {0x1CEE, 0x1CF3, prALetter}, // Lo [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA - {0x1CF4, 0x1CF4, prExtend}, // Mn VEDIC TONE CANDRA ABOVE - {0x1CF5, 0x1CF6, prALetter}, // Lo [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA - {0x1CF7, 0x1CF7, prExtend}, // Mc VEDIC SIGN ATIKRAMA - {0x1CF8, 0x1CF9, prExtend}, // Mn [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE - {0x1CFA, 0x1CFA, prALetter}, // Lo VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA - {0x1D00, 0x1D2B, prALetter}, // L& [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL - {0x1D2C, 0x1D6A, prALetter}, // Lm [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI - {0x1D6B, 0x1D77, prALetter}, // L& [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G - {0x1D78, 0x1D78, prALetter}, // Lm MODIFIER LETTER CYRILLIC EN - {0x1D79, 0x1D9A, prALetter}, // L& [34] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK - {0x1D9B, 0x1DBF, prALetter}, // Lm [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA - {0x1DC0, 0x1DFF, prExtend}, // Mn [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW - {0x1E00, 0x1F15, prALetter}, // L& [278] LATIN CAPITAL LETTER A WITH RING BELOW..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA - {0x1F18, 0x1F1D, prALetter}, // L& [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA - {0x1F20, 0x1F45, prALetter}, // L& [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA - {0x1F48, 0x1F4D, prALetter}, // L& [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA - {0x1F50, 0x1F57, prALetter}, // L& [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI - {0x1F59, 0x1F59, prALetter}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA - {0x1F5B, 0x1F5B, prALetter}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA - {0x1F5D, 0x1F5D, prALetter}, // L& GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA - {0x1F5F, 0x1F7D, prALetter}, // L& [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA - {0x1F80, 0x1FB4, prALetter}, // L& [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI - {0x1FB6, 0x1FBC, prALetter}, // L& [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI - {0x1FBE, 0x1FBE, prALetter}, // L& GREEK PROSGEGRAMMENI - {0x1FC2, 0x1FC4, prALetter}, // L& [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI - {0x1FC6, 0x1FCC, prALetter}, // L& [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI - {0x1FD0, 0x1FD3, prALetter}, // L& [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA - {0x1FD6, 0x1FDB, prALetter}, // L& [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA - {0x1FE0, 0x1FEC, prALetter}, // L& [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA - {0x1FF2, 0x1FF4, prALetter}, // L& [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI - {0x1FF6, 0x1FFC, prALetter}, // L& [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI - {0x2000, 0x2006, prWSegSpace}, // Zs [7] EN QUAD..SIX-PER-EM SPACE - {0x2008, 0x200A, prWSegSpace}, // Zs [3] PUNCTUATION SPACE..HAIR SPACE - {0x200C, 0x200C, prExtend}, // Cf ZERO WIDTH NON-JOINER - {0x200D, 0x200D, prZWJ}, // Cf ZERO WIDTH JOINER - {0x200E, 0x200F, prFormat}, // Cf [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT MARK - {0x2018, 0x2018, prMidNumLet}, // Pi LEFT SINGLE QUOTATION MARK - {0x2019, 0x2019, prMidNumLet}, // Pf RIGHT SINGLE QUOTATION MARK - {0x2024, 0x2024, prMidNumLet}, // Po ONE DOT LEADER - {0x2027, 0x2027, prMidLetter}, // Po HYPHENATION POINT - {0x2028, 0x2028, prNewline}, // Zl LINE SEPARATOR - {0x2029, 0x2029, prNewline}, // Zp PARAGRAPH SEPARATOR - {0x202A, 0x202E, prFormat}, // Cf [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE - {0x202F, 0x202F, prExtendNumLet}, // Zs NARROW NO-BREAK SPACE - {0x203C, 0x203C, prExtendedPictographic}, // E0.6 [1] (‼️) double exclamation mark - {0x203F, 0x2040, prExtendNumLet}, // Pc [2] UNDERTIE..CHARACTER TIE - {0x2044, 0x2044, prMidNum}, // Sm FRACTION SLASH - {0x2049, 0x2049, prExtendedPictographic}, // E0.6 [1] (⁉️) exclamation question mark - {0x2054, 0x2054, prExtendNumLet}, // Pc INVERTED UNDERTIE - {0x205F, 0x205F, prWSegSpace}, // Zs MEDIUM MATHEMATICAL SPACE - {0x2060, 0x2064, prFormat}, // Cf [5] WORD JOINER..INVISIBLE PLUS - {0x2066, 0x206F, prFormat}, // Cf [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES - {0x2071, 0x2071, prALetter}, // Lm SUPERSCRIPT LATIN SMALL LETTER I - {0x207F, 0x207F, prALetter}, // Lm SUPERSCRIPT LATIN SMALL LETTER N - {0x2090, 0x209C, prALetter}, // Lm [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T - {0x20D0, 0x20DC, prExtend}, // Mn [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE - {0x20DD, 0x20E0, prExtend}, // Me [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH - {0x20E1, 0x20E1, prExtend}, // Mn COMBINING LEFT RIGHT ARROW ABOVE - {0x20E2, 0x20E4, prExtend}, // Me [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE - {0x20E5, 0x20F0, prExtend}, // Mn [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE - {0x2102, 0x2102, prALetter}, // L& DOUBLE-STRUCK CAPITAL C - {0x2107, 0x2107, prALetter}, // L& EULER CONSTANT - {0x210A, 0x2113, prALetter}, // L& [10] SCRIPT SMALL G..SCRIPT SMALL L - {0x2115, 0x2115, prALetter}, // L& DOUBLE-STRUCK CAPITAL N - {0x2119, 0x211D, prALetter}, // L& [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R - {0x2122, 0x2122, prExtendedPictographic}, // E0.6 [1] (™️) trade mark - {0x2124, 0x2124, prALetter}, // L& DOUBLE-STRUCK CAPITAL Z - {0x2126, 0x2126, prALetter}, // L& OHM SIGN - {0x2128, 0x2128, prALetter}, // L& BLACK-LETTER CAPITAL Z - {0x212A, 0x212D, prALetter}, // L& [4] KELVIN SIGN..BLACK-LETTER CAPITAL C - {0x212F, 0x2134, prALetter}, // L& [6] SCRIPT SMALL E..SCRIPT SMALL O - {0x2135, 0x2138, prALetter}, // Lo [4] ALEF SYMBOL..DALET SYMBOL - {0x2139, 0x2139, prExtendedPictographic}, // E0.6 [1] (ℹ️) information - {0x2139, 0x2139, prALetter}, // L& INFORMATION SOURCE - {0x213C, 0x213F, prALetter}, // L& [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI - {0x2145, 0x2149, prALetter}, // L& [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J - {0x214E, 0x214E, prALetter}, // L& TURNED SMALL F - {0x2160, 0x2182, prALetter}, // Nl [35] ROMAN NUMERAL ONE..ROMAN NUMERAL TEN THOUSAND - {0x2183, 0x2184, prALetter}, // L& [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C - {0x2185, 0x2188, prALetter}, // Nl [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND - {0x2194, 0x2199, prExtendedPictographic}, // E0.6 [6] (↔️..↙️) left-right arrow..down-left arrow - {0x21A9, 0x21AA, prExtendedPictographic}, // E0.6 [2] (↩️..↪️) right arrow curving left..left arrow curving right - {0x231A, 0x231B, prExtendedPictographic}, // E0.6 [2] (⌚..⌛) watch..hourglass done - {0x2328, 0x2328, prExtendedPictographic}, // E1.0 [1] (⌨️) keyboard - {0x2388, 0x2388, prExtendedPictographic}, // E0.0 [1] (⎈) HELM SYMBOL - {0x23CF, 0x23CF, prExtendedPictographic}, // E1.0 [1] (⏏️) eject button - {0x23E9, 0x23EC, prExtendedPictographic}, // E0.6 [4] (⏩..⏬) fast-forward button..fast down button - {0x23ED, 0x23EE, prExtendedPictographic}, // E0.7 [2] (⏭️..⏮️) next track button..last track button - {0x23EF, 0x23EF, prExtendedPictographic}, // E1.0 [1] (⏯️) play or pause button - {0x23F0, 0x23F0, prExtendedPictographic}, // E0.6 [1] (⏰) alarm clock - {0x23F1, 0x23F2, prExtendedPictographic}, // E1.0 [2] (⏱️..⏲️) stopwatch..timer clock - {0x23F3, 0x23F3, prExtendedPictographic}, // E0.6 [1] (⏳) hourglass not done - {0x23F8, 0x23FA, prExtendedPictographic}, // E0.7 [3] (⏸️..⏺️) pause button..record button - {0x24B6, 0x24E9, prALetter}, // So [52] CIRCLED LATIN CAPITAL LETTER A..CIRCLED LATIN SMALL LETTER Z - {0x24C2, 0x24C2, prExtendedPictographic}, // E0.6 [1] (Ⓜ️) circled M - {0x25AA, 0x25AB, prExtendedPictographic}, // E0.6 [2] (▪️..▫️) black small square..white small square - {0x25B6, 0x25B6, prExtendedPictographic}, // E0.6 [1] (▶️) play button - {0x25C0, 0x25C0, prExtendedPictographic}, // E0.6 [1] (◀️) reverse button - {0x25FB, 0x25FE, prExtendedPictographic}, // E0.6 [4] (◻️..◾) white medium square..black medium-small square - {0x2600, 0x2601, prExtendedPictographic}, // E0.6 [2] (☀️..☁️) sun..cloud - {0x2602, 0x2603, prExtendedPictographic}, // E0.7 [2] (☂️..☃️) umbrella..snowman - {0x2604, 0x2604, prExtendedPictographic}, // E1.0 [1] (☄️) comet - {0x2605, 0x2605, prExtendedPictographic}, // E0.0 [1] (★) BLACK STAR - {0x2607, 0x260D, prExtendedPictographic}, // E0.0 [7] (☇..☍) LIGHTNING..OPPOSITION - {0x260E, 0x260E, prExtendedPictographic}, // E0.6 [1] (☎️) telephone - {0x260F, 0x2610, prExtendedPictographic}, // E0.0 [2] (☏..☐) WHITE TELEPHONE..BALLOT BOX - {0x2611, 0x2611, prExtendedPictographic}, // E0.6 [1] (☑️) check box with check - {0x2612, 0x2612, prExtendedPictographic}, // E0.0 [1] (☒) BALLOT BOX WITH X - {0x2614, 0x2615, prExtendedPictographic}, // E0.6 [2] (☔..☕) umbrella with rain drops..hot beverage - {0x2616, 0x2617, prExtendedPictographic}, // E0.0 [2] (☖..☗) WHITE SHOGI PIECE..BLACK SHOGI PIECE - {0x2618, 0x2618, prExtendedPictographic}, // E1.0 [1] (☘️) shamrock - {0x2619, 0x261C, prExtendedPictographic}, // E0.0 [4] (☙..☜) REVERSED ROTATED FLORAL HEART BULLET..WHITE LEFT POINTING INDEX - {0x261D, 0x261D, prExtendedPictographic}, // E0.6 [1] (☝️) index pointing up - {0x261E, 0x261F, prExtendedPictographic}, // E0.0 [2] (☞..☟) WHITE RIGHT POINTING INDEX..WHITE DOWN POINTING INDEX - {0x2620, 0x2620, prExtendedPictographic}, // E1.0 [1] (☠️) skull and crossbones - {0x2621, 0x2621, prExtendedPictographic}, // E0.0 [1] (☡) CAUTION SIGN - {0x2622, 0x2623, prExtendedPictographic}, // E1.0 [2] (☢️..☣️) radioactive..biohazard - {0x2624, 0x2625, prExtendedPictographic}, // E0.0 [2] (☤..☥) CADUCEUS..ANKH - {0x2626, 0x2626, prExtendedPictographic}, // E1.0 [1] (☦️) orthodox cross - {0x2627, 0x2629, prExtendedPictographic}, // E0.0 [3] (☧..☩) CHI RHO..CROSS OF JERUSALEM - {0x262A, 0x262A, prExtendedPictographic}, // E0.7 [1] (☪️) star and crescent - {0x262B, 0x262D, prExtendedPictographic}, // E0.0 [3] (☫..☭) FARSI SYMBOL..HAMMER AND SICKLE - {0x262E, 0x262E, prExtendedPictographic}, // E1.0 [1] (☮️) peace symbol - {0x262F, 0x262F, prExtendedPictographic}, // E0.7 [1] (☯️) yin yang - {0x2630, 0x2637, prExtendedPictographic}, // E0.0 [8] (☰..☷) TRIGRAM FOR HEAVEN..TRIGRAM FOR EARTH - {0x2638, 0x2639, prExtendedPictographic}, // E0.7 [2] (☸️..☹️) wheel of dharma..frowning face - {0x263A, 0x263A, prExtendedPictographic}, // E0.6 [1] (☺️) smiling face - {0x263B, 0x263F, prExtendedPictographic}, // E0.0 [5] (☻..☿) BLACK SMILING FACE..MERCURY - {0x2640, 0x2640, prExtendedPictographic}, // E4.0 [1] (♀️) female sign - {0x2641, 0x2641, prExtendedPictographic}, // E0.0 [1] (♁) EARTH - {0x2642, 0x2642, prExtendedPictographic}, // E4.0 [1] (♂️) male sign - {0x2643, 0x2647, prExtendedPictographic}, // E0.0 [5] (♃..♇) JUPITER..PLUTO - {0x2648, 0x2653, prExtendedPictographic}, // E0.6 [12] (♈..♓) Aries..Pisces - {0x2654, 0x265E, prExtendedPictographic}, // E0.0 [11] (♔..♞) WHITE CHESS KING..BLACK CHESS KNIGHT - {0x265F, 0x265F, prExtendedPictographic}, // E11.0 [1] (♟️) chess pawn - {0x2660, 0x2660, prExtendedPictographic}, // E0.6 [1] (♠️) spade suit - {0x2661, 0x2662, prExtendedPictographic}, // E0.0 [2] (♡..♢) WHITE HEART SUIT..WHITE DIAMOND SUIT - {0x2663, 0x2663, prExtendedPictographic}, // E0.6 [1] (♣️) club suit - {0x2664, 0x2664, prExtendedPictographic}, // E0.0 [1] (♤) WHITE SPADE SUIT - {0x2665, 0x2666, prExtendedPictographic}, // E0.6 [2] (♥️..♦️) heart suit..diamond suit - {0x2667, 0x2667, prExtendedPictographic}, // E0.0 [1] (♧) WHITE CLUB SUIT - {0x2668, 0x2668, prExtendedPictographic}, // E0.6 [1] (♨️) hot springs - {0x2669, 0x267A, prExtendedPictographic}, // E0.0 [18] (♩..♺) QUARTER NOTE..RECYCLING SYMBOL FOR GENERIC MATERIALS - {0x267B, 0x267B, prExtendedPictographic}, // E0.6 [1] (♻️) recycling symbol - {0x267C, 0x267D, prExtendedPictographic}, // E0.0 [2] (♼..♽) RECYCLED PAPER SYMBOL..PARTIALLY-RECYCLED PAPER SYMBOL - {0x267E, 0x267E, prExtendedPictographic}, // E11.0 [1] (♾️) infinity - {0x267F, 0x267F, prExtendedPictographic}, // E0.6 [1] (♿) wheelchair symbol - {0x2680, 0x2685, prExtendedPictographic}, // E0.0 [6] (⚀..⚅) DIE FACE-1..DIE FACE-6 - {0x2690, 0x2691, prExtendedPictographic}, // E0.0 [2] (⚐..⚑) WHITE FLAG..BLACK FLAG - {0x2692, 0x2692, prExtendedPictographic}, // E1.0 [1] (⚒️) hammer and pick - {0x2693, 0x2693, prExtendedPictographic}, // E0.6 [1] (⚓) anchor - {0x2694, 0x2694, prExtendedPictographic}, // E1.0 [1] (⚔️) crossed swords - {0x2695, 0x2695, prExtendedPictographic}, // E4.0 [1] (⚕️) medical symbol - {0x2696, 0x2697, prExtendedPictographic}, // E1.0 [2] (⚖️..⚗️) balance scale..alembic - {0x2698, 0x2698, prExtendedPictographic}, // E0.0 [1] (⚘) FLOWER - {0x2699, 0x2699, prExtendedPictographic}, // E1.0 [1] (⚙️) gear - {0x269A, 0x269A, prExtendedPictographic}, // E0.0 [1] (⚚) STAFF OF HERMES - {0x269B, 0x269C, prExtendedPictographic}, // E1.0 [2] (⚛️..⚜️) atom symbol..fleur-de-lis - {0x269D, 0x269F, prExtendedPictographic}, // E0.0 [3] (⚝..⚟) OUTLINED WHITE STAR..THREE LINES CONVERGING LEFT - {0x26A0, 0x26A1, prExtendedPictographic}, // E0.6 [2] (⚠️..⚡) warning..high voltage - {0x26A2, 0x26A6, prExtendedPictographic}, // E0.0 [5] (⚢..⚦) DOUBLED FEMALE SIGN..MALE WITH STROKE SIGN - {0x26A7, 0x26A7, prExtendedPictographic}, // E13.0 [1] (⚧️) transgender symbol - {0x26A8, 0x26A9, prExtendedPictographic}, // E0.0 [2] (⚨..⚩) VERTICAL MALE WITH STROKE SIGN..HORIZONTAL MALE WITH STROKE SIGN - {0x26AA, 0x26AB, prExtendedPictographic}, // E0.6 [2] (⚪..⚫) white circle..black circle - {0x26AC, 0x26AF, prExtendedPictographic}, // E0.0 [4] (⚬..⚯) MEDIUM SMALL WHITE CIRCLE..UNMARRIED PARTNERSHIP SYMBOL - {0x26B0, 0x26B1, prExtendedPictographic}, // E1.0 [2] (⚰️..⚱️) coffin..funeral urn - {0x26B2, 0x26BC, prExtendedPictographic}, // E0.0 [11] (⚲..⚼) NEUTER..SESQUIQUADRATE - {0x26BD, 0x26BE, prExtendedPictographic}, // E0.6 [2] (⚽..⚾) soccer ball..baseball - {0x26BF, 0x26C3, prExtendedPictographic}, // E0.0 [5] (⚿..⛃) SQUARED KEY..BLACK DRAUGHTS KING - {0x26C4, 0x26C5, prExtendedPictographic}, // E0.6 [2] (⛄..⛅) snowman without snow..sun behind cloud - {0x26C6, 0x26C7, prExtendedPictographic}, // E0.0 [2] (⛆..⛇) RAIN..BLACK SNOWMAN - {0x26C8, 0x26C8, prExtendedPictographic}, // E0.7 [1] (⛈️) cloud with lightning and rain - {0x26C9, 0x26CD, prExtendedPictographic}, // E0.0 [5] (⛉..⛍) TURNED WHITE SHOGI PIECE..DISABLED CAR - {0x26CE, 0x26CE, prExtendedPictographic}, // E0.6 [1] (⛎) Ophiuchus - {0x26CF, 0x26CF, prExtendedPictographic}, // E0.7 [1] (⛏️) pick - {0x26D0, 0x26D0, prExtendedPictographic}, // E0.0 [1] (⛐) CAR SLIDING - {0x26D1, 0x26D1, prExtendedPictographic}, // E0.7 [1] (⛑️) rescue worker’s helmet - {0x26D2, 0x26D2, prExtendedPictographic}, // E0.0 [1] (⛒) CIRCLED CROSSING LANES - {0x26D3, 0x26D3, prExtendedPictographic}, // E0.7 [1] (⛓️) chains - {0x26D4, 0x26D4, prExtendedPictographic}, // E0.6 [1] (⛔) no entry - {0x26D5, 0x26E8, prExtendedPictographic}, // E0.0 [20] (⛕..⛨) ALTERNATE ONE-WAY LEFT WAY TRAFFIC..BLACK CROSS ON SHIELD - {0x26E9, 0x26E9, prExtendedPictographic}, // E0.7 [1] (⛩️) shinto shrine - {0x26EA, 0x26EA, prExtendedPictographic}, // E0.6 [1] (⛪) church - {0x26EB, 0x26EF, prExtendedPictographic}, // E0.0 [5] (⛫..⛯) CASTLE..MAP SYMBOL FOR LIGHTHOUSE - {0x26F0, 0x26F1, prExtendedPictographic}, // E0.7 [2] (⛰️..⛱️) mountain..umbrella on ground - {0x26F2, 0x26F3, prExtendedPictographic}, // E0.6 [2] (⛲..⛳) fountain..flag in hole - {0x26F4, 0x26F4, prExtendedPictographic}, // E0.7 [1] (⛴️) ferry - {0x26F5, 0x26F5, prExtendedPictographic}, // E0.6 [1] (⛵) sailboat - {0x26F6, 0x26F6, prExtendedPictographic}, // E0.0 [1] (⛶) SQUARE FOUR CORNERS - {0x26F7, 0x26F9, prExtendedPictographic}, // E0.7 [3] (⛷️..⛹️) skier..person bouncing ball - {0x26FA, 0x26FA, prExtendedPictographic}, // E0.6 [1] (⛺) tent - {0x26FB, 0x26FC, prExtendedPictographic}, // E0.0 [2] (⛻..⛼) JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL - {0x26FD, 0x26FD, prExtendedPictographic}, // E0.6 [1] (⛽) fuel pump - {0x26FE, 0x2701, prExtendedPictographic}, // E0.0 [4] (⛾..✁) CUP ON BLACK SQUARE..UPPER BLADE SCISSORS - {0x2702, 0x2702, prExtendedPictographic}, // E0.6 [1] (✂️) scissors - {0x2703, 0x2704, prExtendedPictographic}, // E0.0 [2] (✃..✄) LOWER BLADE SCISSORS..WHITE SCISSORS - {0x2705, 0x2705, prExtendedPictographic}, // E0.6 [1] (✅) check mark button - {0x2708, 0x270C, prExtendedPictographic}, // E0.6 [5] (✈️..✌️) airplane..victory hand - {0x270D, 0x270D, prExtendedPictographic}, // E0.7 [1] (✍️) writing hand - {0x270E, 0x270E, prExtendedPictographic}, // E0.0 [1] (✎) LOWER RIGHT PENCIL - {0x270F, 0x270F, prExtendedPictographic}, // E0.6 [1] (✏️) pencil - {0x2710, 0x2711, prExtendedPictographic}, // E0.0 [2] (✐..✑) UPPER RIGHT PENCIL..WHITE NIB - {0x2712, 0x2712, prExtendedPictographic}, // E0.6 [1] (✒️) black nib - {0x2714, 0x2714, prExtendedPictographic}, // E0.6 [1] (✔️) check mark - {0x2716, 0x2716, prExtendedPictographic}, // E0.6 [1] (✖️) multiply - {0x271D, 0x271D, prExtendedPictographic}, // E0.7 [1] (✝️) latin cross - {0x2721, 0x2721, prExtendedPictographic}, // E0.7 [1] (✡️) star of David - {0x2728, 0x2728, prExtendedPictographic}, // E0.6 [1] (✨) sparkles - {0x2733, 0x2734, prExtendedPictographic}, // E0.6 [2] (✳️..✴️) eight-spoked asterisk..eight-pointed star - {0x2744, 0x2744, prExtendedPictographic}, // E0.6 [1] (❄️) snowflake - {0x2747, 0x2747, prExtendedPictographic}, // E0.6 [1] (❇️) sparkle - {0x274C, 0x274C, prExtendedPictographic}, // E0.6 [1] (❌) cross mark - {0x274E, 0x274E, prExtendedPictographic}, // E0.6 [1] (❎) cross mark button - {0x2753, 0x2755, prExtendedPictographic}, // E0.6 [3] (❓..❕) red question mark..white exclamation mark - {0x2757, 0x2757, prExtendedPictographic}, // E0.6 [1] (❗) red exclamation mark - {0x2763, 0x2763, prExtendedPictographic}, // E1.0 [1] (❣️) heart exclamation - {0x2764, 0x2764, prExtendedPictographic}, // E0.6 [1] (❤️) red heart - {0x2765, 0x2767, prExtendedPictographic}, // E0.0 [3] (❥..❧) ROTATED HEAVY BLACK HEART BULLET..ROTATED FLORAL HEART BULLET - {0x2795, 0x2797, prExtendedPictographic}, // E0.6 [3] (➕..➗) plus..divide - {0x27A1, 0x27A1, prExtendedPictographic}, // E0.6 [1] (➡️) right arrow - {0x27B0, 0x27B0, prExtendedPictographic}, // E0.6 [1] (➰) curly loop - {0x27BF, 0x27BF, prExtendedPictographic}, // E1.0 [1] (➿) double curly loop - {0x2934, 0x2935, prExtendedPictographic}, // E0.6 [2] (⤴️..⤵️) right arrow curving up..right arrow curving down - {0x2B05, 0x2B07, prExtendedPictographic}, // E0.6 [3] (⬅️..⬇️) left arrow..down arrow - {0x2B1B, 0x2B1C, prExtendedPictographic}, // E0.6 [2] (⬛..⬜) black large square..white large square - {0x2B50, 0x2B50, prExtendedPictographic}, // E0.6 [1] (⭐) star - {0x2B55, 0x2B55, prExtendedPictographic}, // E0.6 [1] (⭕) hollow red circle - {0x2C00, 0x2C7B, prALetter}, // L& [124] GLAGOLITIC CAPITAL LETTER AZU..LATIN LETTER SMALL CAPITAL TURNED E - {0x2C7C, 0x2C7D, prALetter}, // Lm [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V - {0x2C7E, 0x2CE4, prALetter}, // L& [103] LATIN CAPITAL LETTER S WITH SWASH TAIL..COPTIC SYMBOL KAI - {0x2CEB, 0x2CEE, prALetter}, // L& [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA - {0x2CEF, 0x2CF1, prExtend}, // Mn [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS - {0x2CF2, 0x2CF3, prALetter}, // L& [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI - {0x2D00, 0x2D25, prALetter}, // L& [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE - {0x2D27, 0x2D27, prALetter}, // L& GEORGIAN SMALL LETTER YN - {0x2D2D, 0x2D2D, prALetter}, // L& GEORGIAN SMALL LETTER AEN - {0x2D30, 0x2D67, prALetter}, // Lo [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO - {0x2D6F, 0x2D6F, prALetter}, // Lm TIFINAGH MODIFIER LETTER LABIALIZATION MARK - {0x2D7F, 0x2D7F, prExtend}, // Mn TIFINAGH CONSONANT JOINER - {0x2D80, 0x2D96, prALetter}, // Lo [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE - {0x2DA0, 0x2DA6, prALetter}, // Lo [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO - {0x2DA8, 0x2DAE, prALetter}, // Lo [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO - {0x2DB0, 0x2DB6, prALetter}, // Lo [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO - {0x2DB8, 0x2DBE, prALetter}, // Lo [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO - {0x2DC0, 0x2DC6, prALetter}, // Lo [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO - {0x2DC8, 0x2DCE, prALetter}, // Lo [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO - {0x2DD0, 0x2DD6, prALetter}, // Lo [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO - {0x2DD8, 0x2DDE, prALetter}, // Lo [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO - {0x2DE0, 0x2DFF, prExtend}, // Mn [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS - {0x2E2F, 0x2E2F, prALetter}, // Lm VERTICAL TILDE - {0x3000, 0x3000, prWSegSpace}, // Zs IDEOGRAPHIC SPACE - {0x3005, 0x3005, prALetter}, // Lm IDEOGRAPHIC ITERATION MARK - {0x302A, 0x302D, prExtend}, // Mn [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK - {0x302E, 0x302F, prExtend}, // Mc [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK - {0x3030, 0x3030, prExtendedPictographic}, // E0.6 [1] (〰️) wavy dash - {0x3031, 0x3035, prKatakana}, // Lm [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF - {0x303B, 0x303B, prALetter}, // Lm VERTICAL IDEOGRAPHIC ITERATION MARK - {0x303C, 0x303C, prALetter}, // Lo MASU MARK - {0x303D, 0x303D, prExtendedPictographic}, // E0.6 [1] (〽️) part alternation mark - {0x3099, 0x309A, prExtend}, // Mn [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x309B, 0x309C, prKatakana}, // Sk [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK - {0x30A0, 0x30A0, prKatakana}, // Pd KATAKANA-HIRAGANA DOUBLE HYPHEN - {0x30A1, 0x30FA, prKatakana}, // Lo [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO - {0x30FC, 0x30FE, prKatakana}, // Lm [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK - {0x30FF, 0x30FF, prKatakana}, // Lo KATAKANA DIGRAPH KOTO - {0x3105, 0x312F, prALetter}, // Lo [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN - {0x3131, 0x318E, prALetter}, // Lo [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE - {0x31A0, 0x31BF, prALetter}, // Lo [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH - {0x31F0, 0x31FF, prKatakana}, // Lo [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO - {0x3297, 0x3297, prExtendedPictographic}, // E0.6 [1] (㊗️) Japanese “congratulations” button - {0x3299, 0x3299, prExtendedPictographic}, // E0.6 [1] (㊙️) Japanese “secret” button - {0x32D0, 0x32FE, prKatakana}, // So [47] CIRCLED KATAKANA A..CIRCLED KATAKANA WO - {0x3300, 0x3357, prKatakana}, // So [88] SQUARE APAATO..SQUARE WATTO - {0xA000, 0xA014, prALetter}, // Lo [21] YI SYLLABLE IT..YI SYLLABLE E - {0xA015, 0xA015, prALetter}, // Lm YI SYLLABLE WU - {0xA016, 0xA48C, prALetter}, // Lo [1143] YI SYLLABLE BIT..YI SYLLABLE YYR - {0xA4D0, 0xA4F7, prALetter}, // Lo [40] LISU LETTER BA..LISU LETTER OE - {0xA4F8, 0xA4FD, prALetter}, // Lm [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU - {0xA500, 0xA60B, prALetter}, // Lo [268] VAI SYLLABLE EE..VAI SYLLABLE NG - {0xA60C, 0xA60C, prALetter}, // Lm VAI SYLLABLE LENGTHENER - {0xA610, 0xA61F, prALetter}, // Lo [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG - {0xA620, 0xA629, prNumeric}, // Nd [10] VAI DIGIT ZERO..VAI DIGIT NINE - {0xA62A, 0xA62B, prALetter}, // Lo [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO - {0xA640, 0xA66D, prALetter}, // L& [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O - {0xA66E, 0xA66E, prALetter}, // Lo CYRILLIC LETTER MULTIOCULAR O - {0xA66F, 0xA66F, prExtend}, // Mn COMBINING CYRILLIC VZMET - {0xA670, 0xA672, prExtend}, // Me [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN - {0xA674, 0xA67D, prExtend}, // Mn [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK - {0xA67F, 0xA67F, prALetter}, // Lm CYRILLIC PAYEROK - {0xA680, 0xA69B, prALetter}, // L& [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O - {0xA69C, 0xA69D, prALetter}, // Lm [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN - {0xA69E, 0xA69F, prExtend}, // Mn [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E - {0xA6A0, 0xA6E5, prALetter}, // Lo [70] BAMUM LETTER A..BAMUM LETTER KI - {0xA6E6, 0xA6EF, prALetter}, // Nl [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM - {0xA6F0, 0xA6F1, prExtend}, // Mn [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS - {0xA708, 0xA716, prALetter}, // Sk [15] MODIFIER LETTER EXTRA-HIGH DOTTED TONE BAR..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR - {0xA717, 0xA71F, prALetter}, // Lm [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK - {0xA720, 0xA721, prALetter}, // Sk [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE - {0xA722, 0xA76F, prALetter}, // L& [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON - {0xA770, 0xA770, prALetter}, // Lm MODIFIER LETTER US - {0xA771, 0xA787, prALetter}, // L& [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T - {0xA788, 0xA788, prALetter}, // Lm MODIFIER LETTER LOW CIRCUMFLEX ACCENT - {0xA789, 0xA78A, prALetter}, // Sk [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN - {0xA78B, 0xA78E, prALetter}, // L& [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT - {0xA78F, 0xA78F, prALetter}, // Lo LATIN LETTER SINOLOGICAL DOT - {0xA790, 0xA7CA, prALetter}, // L& [59] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY - {0xA7D0, 0xA7D1, prALetter}, // L& [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G - {0xA7D3, 0xA7D3, prALetter}, // L& LATIN SMALL LETTER DOUBLE THORN - {0xA7D5, 0xA7D9, prALetter}, // L& [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S - {0xA7F2, 0xA7F4, prALetter}, // Lm [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q - {0xA7F5, 0xA7F6, prALetter}, // L& [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H - {0xA7F7, 0xA7F7, prALetter}, // Lo LATIN EPIGRAPHIC LETTER SIDEWAYS I - {0xA7F8, 0xA7F9, prALetter}, // Lm [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE - {0xA7FA, 0xA7FA, prALetter}, // L& LATIN LETTER SMALL CAPITAL TURNED M - {0xA7FB, 0xA801, prALetter}, // Lo [7] LATIN EPIGRAPHIC LETTER REVERSED F..SYLOTI NAGRI LETTER I - {0xA802, 0xA802, prExtend}, // Mn SYLOTI NAGRI SIGN DVISVARA - {0xA803, 0xA805, prALetter}, // Lo [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O - {0xA806, 0xA806, prExtend}, // Mn SYLOTI NAGRI SIGN HASANTA - {0xA807, 0xA80A, prALetter}, // Lo [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO - {0xA80B, 0xA80B, prExtend}, // Mn SYLOTI NAGRI SIGN ANUSVARA - {0xA80C, 0xA822, prALetter}, // Lo [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO - {0xA823, 0xA824, prExtend}, // Mc [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I - {0xA825, 0xA826, prExtend}, // Mn [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E - {0xA827, 0xA827, prExtend}, // Mc SYLOTI NAGRI VOWEL SIGN OO - {0xA82C, 0xA82C, prExtend}, // Mn SYLOTI NAGRI SIGN ALTERNATE HASANTA - {0xA840, 0xA873, prALetter}, // Lo [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU - {0xA880, 0xA881, prExtend}, // Mc [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA - {0xA882, 0xA8B3, prALetter}, // Lo [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA - {0xA8B4, 0xA8C3, prExtend}, // Mc [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU - {0xA8C4, 0xA8C5, prExtend}, // Mn [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU - {0xA8D0, 0xA8D9, prNumeric}, // Nd [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE - {0xA8E0, 0xA8F1, prExtend}, // Mn [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA - {0xA8F2, 0xA8F7, prALetter}, // Lo [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA - {0xA8FB, 0xA8FB, prALetter}, // Lo DEVANAGARI HEADSTROKE - {0xA8FD, 0xA8FE, prALetter}, // Lo [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY - {0xA8FF, 0xA8FF, prExtend}, // Mn DEVANAGARI VOWEL SIGN AY - {0xA900, 0xA909, prNumeric}, // Nd [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE - {0xA90A, 0xA925, prALetter}, // Lo [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO - {0xA926, 0xA92D, prExtend}, // Mn [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU - {0xA930, 0xA946, prALetter}, // Lo [23] REJANG LETTER KA..REJANG LETTER A - {0xA947, 0xA951, prExtend}, // Mn [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R - {0xA952, 0xA953, prExtend}, // Mc [2] REJANG CONSONANT SIGN H..REJANG VIRAMA - {0xA960, 0xA97C, prALetter}, // Lo [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH - {0xA980, 0xA982, prExtend}, // Mn [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR - {0xA983, 0xA983, prExtend}, // Mc JAVANESE SIGN WIGNYAN - {0xA984, 0xA9B2, prALetter}, // Lo [47] JAVANESE LETTER A..JAVANESE LETTER HA - {0xA9B3, 0xA9B3, prExtend}, // Mn JAVANESE SIGN CECAK TELU - {0xA9B4, 0xA9B5, prExtend}, // Mc [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG - {0xA9B6, 0xA9B9, prExtend}, // Mn [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT - {0xA9BA, 0xA9BB, prExtend}, // Mc [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE - {0xA9BC, 0xA9BD, prExtend}, // Mn [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET - {0xA9BE, 0xA9C0, prExtend}, // Mc [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON - {0xA9CF, 0xA9CF, prALetter}, // Lm JAVANESE PANGRANGKEP - {0xA9D0, 0xA9D9, prNumeric}, // Nd [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE - {0xA9E5, 0xA9E5, prExtend}, // Mn MYANMAR SIGN SHAN SAW - {0xA9F0, 0xA9F9, prNumeric}, // Nd [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE - {0xAA00, 0xAA28, prALetter}, // Lo [41] CHAM LETTER A..CHAM LETTER HA - {0xAA29, 0xAA2E, prExtend}, // Mn [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE - {0xAA2F, 0xAA30, prExtend}, // Mc [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI - {0xAA31, 0xAA32, prExtend}, // Mn [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE - {0xAA33, 0xAA34, prExtend}, // Mc [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA - {0xAA35, 0xAA36, prExtend}, // Mn [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA - {0xAA40, 0xAA42, prALetter}, // Lo [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG - {0xAA43, 0xAA43, prExtend}, // Mn CHAM CONSONANT SIGN FINAL NG - {0xAA44, 0xAA4B, prALetter}, // Lo [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS - {0xAA4C, 0xAA4C, prExtend}, // Mn CHAM CONSONANT SIGN FINAL M - {0xAA4D, 0xAA4D, prExtend}, // Mc CHAM CONSONANT SIGN FINAL H - {0xAA50, 0xAA59, prNumeric}, // Nd [10] CHAM DIGIT ZERO..CHAM DIGIT NINE - {0xAA7B, 0xAA7B, prExtend}, // Mc MYANMAR SIGN PAO KAREN TONE - {0xAA7C, 0xAA7C, prExtend}, // Mn MYANMAR SIGN TAI LAING TONE-2 - {0xAA7D, 0xAA7D, prExtend}, // Mc MYANMAR SIGN TAI LAING TONE-5 - {0xAAB0, 0xAAB0, prExtend}, // Mn TAI VIET MAI KANG - {0xAAB2, 0xAAB4, prExtend}, // Mn [3] TAI VIET VOWEL I..TAI VIET VOWEL U - {0xAAB7, 0xAAB8, prExtend}, // Mn [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA - {0xAABE, 0xAABF, prExtend}, // Mn [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK - {0xAAC1, 0xAAC1, prExtend}, // Mn TAI VIET TONE MAI THO - {0xAAE0, 0xAAEA, prALetter}, // Lo [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA - {0xAAEB, 0xAAEB, prExtend}, // Mc MEETEI MAYEK VOWEL SIGN II - {0xAAEC, 0xAAED, prExtend}, // Mn [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI - {0xAAEE, 0xAAEF, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU - {0xAAF2, 0xAAF2, prALetter}, // Lo MEETEI MAYEK ANJI - {0xAAF3, 0xAAF4, prALetter}, // Lm [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK - {0xAAF5, 0xAAF5, prExtend}, // Mc MEETEI MAYEK VOWEL SIGN VISARGA - {0xAAF6, 0xAAF6, prExtend}, // Mn MEETEI MAYEK VIRAMA - {0xAB01, 0xAB06, prALetter}, // Lo [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO - {0xAB09, 0xAB0E, prALetter}, // Lo [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO - {0xAB11, 0xAB16, prALetter}, // Lo [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO - {0xAB20, 0xAB26, prALetter}, // Lo [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO - {0xAB28, 0xAB2E, prALetter}, // Lo [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO - {0xAB30, 0xAB5A, prALetter}, // L& [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG - {0xAB5B, 0xAB5B, prALetter}, // Sk MODIFIER BREVE WITH INVERTED BREVE - {0xAB5C, 0xAB5F, prALetter}, // Lm [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK - {0xAB60, 0xAB68, prALetter}, // L& [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE - {0xAB69, 0xAB69, prALetter}, // Lm MODIFIER LETTER SMALL TURNED W - {0xAB70, 0xABBF, prALetter}, // L& [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA - {0xABC0, 0xABE2, prALetter}, // Lo [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM - {0xABE3, 0xABE4, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP - {0xABE5, 0xABE5, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN ANAP - {0xABE6, 0xABE7, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP - {0xABE8, 0xABE8, prExtend}, // Mn MEETEI MAYEK VOWEL SIGN UNAP - {0xABE9, 0xABEA, prExtend}, // Mc [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG - {0xABEC, 0xABEC, prExtend}, // Mc MEETEI MAYEK LUM IYEK - {0xABED, 0xABED, prExtend}, // Mn MEETEI MAYEK APUN IYEK - {0xABF0, 0xABF9, prNumeric}, // Nd [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE - {0xAC00, 0xD7A3, prALetter}, // Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH - {0xD7B0, 0xD7C6, prALetter}, // Lo [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E - {0xD7CB, 0xD7FB, prALetter}, // Lo [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH - {0xFB00, 0xFB06, prALetter}, // L& [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST - {0xFB13, 0xFB17, prALetter}, // L& [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH - {0xFB1D, 0xFB1D, prHebrewLetter}, // Lo HEBREW LETTER YOD WITH HIRIQ - {0xFB1E, 0xFB1E, prExtend}, // Mn HEBREW POINT JUDEO-SPANISH VARIKA - {0xFB1F, 0xFB28, prHebrewLetter}, // Lo [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV - {0xFB2A, 0xFB36, prHebrewLetter}, // Lo [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH - {0xFB38, 0xFB3C, prHebrewLetter}, // Lo [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH - {0xFB3E, 0xFB3E, prHebrewLetter}, // Lo HEBREW LETTER MEM WITH DAGESH - {0xFB40, 0xFB41, prHebrewLetter}, // Lo [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH - {0xFB43, 0xFB44, prHebrewLetter}, // Lo [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH - {0xFB46, 0xFB4F, prHebrewLetter}, // Lo [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED - {0xFB50, 0xFBB1, prALetter}, // Lo [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM - {0xFBD3, 0xFD3D, prALetter}, // Lo [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM - {0xFD50, 0xFD8F, prALetter}, // Lo [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM - {0xFD92, 0xFDC7, prALetter}, // Lo [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM - {0xFDF0, 0xFDFB, prALetter}, // Lo [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU - {0xFE00, 0xFE0F, prExtend}, // Mn [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16 - {0xFE10, 0xFE10, prMidNum}, // Po PRESENTATION FORM FOR VERTICAL COMMA - {0xFE13, 0xFE13, prMidLetter}, // Po PRESENTATION FORM FOR VERTICAL COLON - {0xFE14, 0xFE14, prMidNum}, // Po PRESENTATION FORM FOR VERTICAL SEMICOLON - {0xFE20, 0xFE2F, prExtend}, // Mn [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF - {0xFE33, 0xFE34, prExtendNumLet}, // Pc [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE - {0xFE4D, 0xFE4F, prExtendNumLet}, // Pc [3] DASHED LOW LINE..WAVY LOW LINE - {0xFE50, 0xFE50, prMidNum}, // Po SMALL COMMA - {0xFE52, 0xFE52, prMidNumLet}, // Po SMALL FULL STOP - {0xFE54, 0xFE54, prMidNum}, // Po SMALL SEMICOLON - {0xFE55, 0xFE55, prMidLetter}, // Po SMALL COLON - {0xFE70, 0xFE74, prALetter}, // Lo [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM - {0xFE76, 0xFEFC, prALetter}, // Lo [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM - {0xFEFF, 0xFEFF, prFormat}, // Cf ZERO WIDTH NO-BREAK SPACE - {0xFF07, 0xFF07, prMidNumLet}, // Po FULLWIDTH APOSTROPHE - {0xFF0C, 0xFF0C, prMidNum}, // Po FULLWIDTH COMMA - {0xFF0E, 0xFF0E, prMidNumLet}, // Po FULLWIDTH FULL STOP - {0xFF10, 0xFF19, prNumeric}, // Nd [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE - {0xFF1A, 0xFF1A, prMidLetter}, // Po FULLWIDTH COLON - {0xFF1B, 0xFF1B, prMidNum}, // Po FULLWIDTH SEMICOLON - {0xFF21, 0xFF3A, prALetter}, // L& [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z - {0xFF3F, 0xFF3F, prExtendNumLet}, // Pc FULLWIDTH LOW LINE - {0xFF41, 0xFF5A, prALetter}, // L& [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z - {0xFF66, 0xFF6F, prKatakana}, // Lo [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU - {0xFF70, 0xFF70, prKatakana}, // Lm HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK - {0xFF71, 0xFF9D, prKatakana}, // Lo [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N - {0xFF9E, 0xFF9F, prExtend}, // Lm [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK - {0xFFA0, 0xFFBE, prALetter}, // Lo [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH - {0xFFC2, 0xFFC7, prALetter}, // Lo [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E - {0xFFCA, 0xFFCF, prALetter}, // Lo [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE - {0xFFD2, 0xFFD7, prALetter}, // Lo [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU - {0xFFDA, 0xFFDC, prALetter}, // Lo [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I - {0xFFF9, 0xFFFB, prFormat}, // Cf [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR - {0x10000, 0x1000B, prALetter}, // Lo [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE - {0x1000D, 0x10026, prALetter}, // Lo [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO - {0x10028, 0x1003A, prALetter}, // Lo [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO - {0x1003C, 0x1003D, prALetter}, // Lo [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE - {0x1003F, 0x1004D, prALetter}, // Lo [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO - {0x10050, 0x1005D, prALetter}, // Lo [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089 - {0x10080, 0x100FA, prALetter}, // Lo [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305 - {0x10140, 0x10174, prALetter}, // Nl [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS - {0x101FD, 0x101FD, prExtend}, // Mn PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE - {0x10280, 0x1029C, prALetter}, // Lo [29] LYCIAN LETTER A..LYCIAN LETTER X - {0x102A0, 0x102D0, prALetter}, // Lo [49] CARIAN LETTER A..CARIAN LETTER UUU3 - {0x102E0, 0x102E0, prExtend}, // Mn COPTIC EPACT THOUSANDS MARK - {0x10300, 0x1031F, prALetter}, // Lo [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS - {0x1032D, 0x10340, prALetter}, // Lo [20] OLD ITALIC LETTER YE..GOTHIC LETTER PAIRTHRA - {0x10341, 0x10341, prALetter}, // Nl GOTHIC LETTER NINETY - {0x10342, 0x10349, prALetter}, // Lo [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL - {0x1034A, 0x1034A, prALetter}, // Nl GOTHIC LETTER NINE HUNDRED - {0x10350, 0x10375, prALetter}, // Lo [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA - {0x10376, 0x1037A, prExtend}, // Mn [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII - {0x10380, 0x1039D, prALetter}, // Lo [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU - {0x103A0, 0x103C3, prALetter}, // Lo [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA - {0x103C8, 0x103CF, prALetter}, // Lo [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH - {0x103D1, 0x103D5, prALetter}, // Nl [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED - {0x10400, 0x1044F, prALetter}, // L& [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW - {0x10450, 0x1049D, prALetter}, // Lo [78] SHAVIAN LETTER PEEP..OSMANYA LETTER OO - {0x104A0, 0x104A9, prNumeric}, // Nd [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE - {0x104B0, 0x104D3, prALetter}, // L& [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA - {0x104D8, 0x104FB, prALetter}, // L& [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA - {0x10500, 0x10527, prALetter}, // Lo [40] ELBASAN LETTER A..ELBASAN LETTER KHE - {0x10530, 0x10563, prALetter}, // Lo [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW - {0x10570, 0x1057A, prALetter}, // L& [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA - {0x1057C, 0x1058A, prALetter}, // L& [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE - {0x1058C, 0x10592, prALetter}, // L& [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE - {0x10594, 0x10595, prALetter}, // L& [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE - {0x10597, 0x105A1, prALetter}, // L& [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA - {0x105A3, 0x105B1, prALetter}, // L& [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE - {0x105B3, 0x105B9, prALetter}, // L& [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE - {0x105BB, 0x105BC, prALetter}, // L& [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE - {0x10600, 0x10736, prALetter}, // Lo [311] LINEAR A SIGN AB001..LINEAR A SIGN A664 - {0x10740, 0x10755, prALetter}, // Lo [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE - {0x10760, 0x10767, prALetter}, // Lo [8] LINEAR A SIGN A800..LINEAR A SIGN A807 - {0x10780, 0x10785, prALetter}, // Lm [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK - {0x10787, 0x107B0, prALetter}, // Lm [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK - {0x107B2, 0x107BA, prALetter}, // Lm [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL - {0x10800, 0x10805, prALetter}, // Lo [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA - {0x10808, 0x10808, prALetter}, // Lo CYPRIOT SYLLABLE JO - {0x1080A, 0x10835, prALetter}, // Lo [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO - {0x10837, 0x10838, prALetter}, // Lo [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE - {0x1083C, 0x1083C, prALetter}, // Lo CYPRIOT SYLLABLE ZA - {0x1083F, 0x10855, prALetter}, // Lo [23] CYPRIOT SYLLABLE ZO..IMPERIAL ARAMAIC LETTER TAW - {0x10860, 0x10876, prALetter}, // Lo [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW - {0x10880, 0x1089E, prALetter}, // Lo [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW - {0x108E0, 0x108F2, prALetter}, // Lo [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH - {0x108F4, 0x108F5, prALetter}, // Lo [2] HATRAN LETTER SHIN..HATRAN LETTER TAW - {0x10900, 0x10915, prALetter}, // Lo [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU - {0x10920, 0x10939, prALetter}, // Lo [26] LYDIAN LETTER A..LYDIAN LETTER C - {0x10980, 0x109B7, prALetter}, // Lo [56] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC CURSIVE LETTER DA - {0x109BE, 0x109BF, prALetter}, // Lo [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN - {0x10A00, 0x10A00, prALetter}, // Lo KHAROSHTHI LETTER A - {0x10A01, 0x10A03, prExtend}, // Mn [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R - {0x10A05, 0x10A06, prExtend}, // Mn [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O - {0x10A0C, 0x10A0F, prExtend}, // Mn [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA - {0x10A10, 0x10A13, prALetter}, // Lo [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA - {0x10A15, 0x10A17, prALetter}, // Lo [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA - {0x10A19, 0x10A35, prALetter}, // Lo [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA - {0x10A38, 0x10A3A, prExtend}, // Mn [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW - {0x10A3F, 0x10A3F, prExtend}, // Mn KHAROSHTHI VIRAMA - {0x10A60, 0x10A7C, prALetter}, // Lo [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH - {0x10A80, 0x10A9C, prALetter}, // Lo [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH - {0x10AC0, 0x10AC7, prALetter}, // Lo [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW - {0x10AC9, 0x10AE4, prALetter}, // Lo [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW - {0x10AE5, 0x10AE6, prExtend}, // Mn [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW - {0x10B00, 0x10B35, prALetter}, // Lo [54] AVESTAN LETTER A..AVESTAN LETTER HE - {0x10B40, 0x10B55, prALetter}, // Lo [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW - {0x10B60, 0x10B72, prALetter}, // Lo [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW - {0x10B80, 0x10B91, prALetter}, // Lo [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW - {0x10C00, 0x10C48, prALetter}, // Lo [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH - {0x10C80, 0x10CB2, prALetter}, // L& [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US - {0x10CC0, 0x10CF2, prALetter}, // L& [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US - {0x10D00, 0x10D23, prALetter}, // Lo [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA - {0x10D24, 0x10D27, prExtend}, // Mn [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI - {0x10D30, 0x10D39, prNumeric}, // Nd [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE - {0x10E80, 0x10EA9, prALetter}, // Lo [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET - {0x10EAB, 0x10EAC, prExtend}, // Mn [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK - {0x10EB0, 0x10EB1, prALetter}, // Lo [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE - {0x10EFD, 0x10EFF, prExtend}, // Mn [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA - {0x10F00, 0x10F1C, prALetter}, // Lo [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL - {0x10F27, 0x10F27, prALetter}, // Lo OLD SOGDIAN LIGATURE AYIN-DALETH - {0x10F30, 0x10F45, prALetter}, // Lo [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN - {0x10F46, 0x10F50, prExtend}, // Mn [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW - {0x10F70, 0x10F81, prALetter}, // Lo [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH - {0x10F82, 0x10F85, prExtend}, // Mn [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW - {0x10FB0, 0x10FC4, prALetter}, // Lo [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW - {0x10FE0, 0x10FF6, prALetter}, // Lo [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH - {0x11000, 0x11000, prExtend}, // Mc BRAHMI SIGN CANDRABINDU - {0x11001, 0x11001, prExtend}, // Mn BRAHMI SIGN ANUSVARA - {0x11002, 0x11002, prExtend}, // Mc BRAHMI SIGN VISARGA - {0x11003, 0x11037, prALetter}, // Lo [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA - {0x11038, 0x11046, prExtend}, // Mn [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA - {0x11066, 0x1106F, prNumeric}, // Nd [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE - {0x11070, 0x11070, prExtend}, // Mn BRAHMI SIGN OLD TAMIL VIRAMA - {0x11071, 0x11072, prALetter}, // Lo [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O - {0x11073, 0x11074, prExtend}, // Mn [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O - {0x11075, 0x11075, prALetter}, // Lo BRAHMI LETTER OLD TAMIL LLA - {0x1107F, 0x11081, prExtend}, // Mn [3] BRAHMI NUMBER JOINER..KAITHI SIGN ANUSVARA - {0x11082, 0x11082, prExtend}, // Mc KAITHI SIGN VISARGA - {0x11083, 0x110AF, prALetter}, // Lo [45] KAITHI LETTER A..KAITHI LETTER HA - {0x110B0, 0x110B2, prExtend}, // Mc [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II - {0x110B3, 0x110B6, prExtend}, // Mn [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI - {0x110B7, 0x110B8, prExtend}, // Mc [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU - {0x110B9, 0x110BA, prExtend}, // Mn [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA - {0x110BD, 0x110BD, prFormat}, // Cf KAITHI NUMBER SIGN - {0x110C2, 0x110C2, prExtend}, // Mn KAITHI VOWEL SIGN VOCALIC R - {0x110CD, 0x110CD, prFormat}, // Cf KAITHI NUMBER SIGN ABOVE - {0x110D0, 0x110E8, prALetter}, // Lo [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE - {0x110F0, 0x110F9, prNumeric}, // Nd [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE - {0x11100, 0x11102, prExtend}, // Mn [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA - {0x11103, 0x11126, prALetter}, // Lo [36] CHAKMA LETTER AA..CHAKMA LETTER HAA - {0x11127, 0x1112B, prExtend}, // Mn [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU - {0x1112C, 0x1112C, prExtend}, // Mc CHAKMA VOWEL SIGN E - {0x1112D, 0x11134, prExtend}, // Mn [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA - {0x11136, 0x1113F, prNumeric}, // Nd [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE - {0x11144, 0x11144, prALetter}, // Lo CHAKMA LETTER LHAA - {0x11145, 0x11146, prExtend}, // Mc [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI - {0x11147, 0x11147, prALetter}, // Lo CHAKMA LETTER VAA - {0x11150, 0x11172, prALetter}, // Lo [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA - {0x11173, 0x11173, prExtend}, // Mn MAHAJANI SIGN NUKTA - {0x11176, 0x11176, prALetter}, // Lo MAHAJANI LIGATURE SHRI - {0x11180, 0x11181, prExtend}, // Mn [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA - {0x11182, 0x11182, prExtend}, // Mc SHARADA SIGN VISARGA - {0x11183, 0x111B2, prALetter}, // Lo [48] SHARADA LETTER A..SHARADA LETTER HA - {0x111B3, 0x111B5, prExtend}, // Mc [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II - {0x111B6, 0x111BE, prExtend}, // Mn [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O - {0x111BF, 0x111C0, prExtend}, // Mc [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA - {0x111C1, 0x111C4, prALetter}, // Lo [4] SHARADA SIGN AVAGRAHA..SHARADA OM - {0x111C9, 0x111CC, prExtend}, // Mn [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK - {0x111CE, 0x111CE, prExtend}, // Mc SHARADA VOWEL SIGN PRISHTHAMATRA E - {0x111CF, 0x111CF, prExtend}, // Mn SHARADA SIGN INVERTED CANDRABINDU - {0x111D0, 0x111D9, prNumeric}, // Nd [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE - {0x111DA, 0x111DA, prALetter}, // Lo SHARADA EKAM - {0x111DC, 0x111DC, prALetter}, // Lo SHARADA HEADSTROKE - {0x11200, 0x11211, prALetter}, // Lo [18] KHOJKI LETTER A..KHOJKI LETTER JJA - {0x11213, 0x1122B, prALetter}, // Lo [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA - {0x1122C, 0x1122E, prExtend}, // Mc [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II - {0x1122F, 0x11231, prExtend}, // Mn [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI - {0x11232, 0x11233, prExtend}, // Mc [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU - {0x11234, 0x11234, prExtend}, // Mn KHOJKI SIGN ANUSVARA - {0x11235, 0x11235, prExtend}, // Mc KHOJKI SIGN VIRAMA - {0x11236, 0x11237, prExtend}, // Mn [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA - {0x1123E, 0x1123E, prExtend}, // Mn KHOJKI SIGN SUKUN - {0x1123F, 0x11240, prALetter}, // Lo [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I - {0x11241, 0x11241, prExtend}, // Mn KHOJKI VOWEL SIGN VOCALIC R - {0x11280, 0x11286, prALetter}, // Lo [7] MULTANI LETTER A..MULTANI LETTER GA - {0x11288, 0x11288, prALetter}, // Lo MULTANI LETTER GHA - {0x1128A, 0x1128D, prALetter}, // Lo [4] MULTANI LETTER CA..MULTANI LETTER JJA - {0x1128F, 0x1129D, prALetter}, // Lo [15] MULTANI LETTER NYA..MULTANI LETTER BA - {0x1129F, 0x112A8, prALetter}, // Lo [10] MULTANI LETTER BHA..MULTANI LETTER RHA - {0x112B0, 0x112DE, prALetter}, // Lo [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA - {0x112DF, 0x112DF, prExtend}, // Mn KHUDAWADI SIGN ANUSVARA - {0x112E0, 0x112E2, prExtend}, // Mc [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II - {0x112E3, 0x112EA, prExtend}, // Mn [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA - {0x112F0, 0x112F9, prNumeric}, // Nd [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE - {0x11300, 0x11301, prExtend}, // Mn [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU - {0x11302, 0x11303, prExtend}, // Mc [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA - {0x11305, 0x1130C, prALetter}, // Lo [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L - {0x1130F, 0x11310, prALetter}, // Lo [2] GRANTHA LETTER EE..GRANTHA LETTER AI - {0x11313, 0x11328, prALetter}, // Lo [22] GRANTHA LETTER OO..GRANTHA LETTER NA - {0x1132A, 0x11330, prALetter}, // Lo [7] GRANTHA LETTER PA..GRANTHA LETTER RA - {0x11332, 0x11333, prALetter}, // Lo [2] GRANTHA LETTER LA..GRANTHA LETTER LLA - {0x11335, 0x11339, prALetter}, // Lo [5] GRANTHA LETTER VA..GRANTHA LETTER HA - {0x1133B, 0x1133C, prExtend}, // Mn [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA - {0x1133D, 0x1133D, prALetter}, // Lo GRANTHA SIGN AVAGRAHA - {0x1133E, 0x1133F, prExtend}, // Mc [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I - {0x11340, 0x11340, prExtend}, // Mn GRANTHA VOWEL SIGN II - {0x11341, 0x11344, prExtend}, // Mc [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR - {0x11347, 0x11348, prExtend}, // Mc [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI - {0x1134B, 0x1134D, prExtend}, // Mc [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA - {0x11350, 0x11350, prALetter}, // Lo GRANTHA OM - {0x11357, 0x11357, prExtend}, // Mc GRANTHA AU LENGTH MARK - {0x1135D, 0x11361, prALetter}, // Lo [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL - {0x11362, 0x11363, prExtend}, // Mc [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL - {0x11366, 0x1136C, prExtend}, // Mn [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX - {0x11370, 0x11374, prExtend}, // Mn [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA - {0x11400, 0x11434, prALetter}, // Lo [53] NEWA LETTER A..NEWA LETTER HA - {0x11435, 0x11437, prExtend}, // Mc [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II - {0x11438, 0x1143F, prExtend}, // Mn [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI - {0x11440, 0x11441, prExtend}, // Mc [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU - {0x11442, 0x11444, prExtend}, // Mn [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA - {0x11445, 0x11445, prExtend}, // Mc NEWA SIGN VISARGA - {0x11446, 0x11446, prExtend}, // Mn NEWA SIGN NUKTA - {0x11447, 0x1144A, prALetter}, // Lo [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI - {0x11450, 0x11459, prNumeric}, // Nd [10] NEWA DIGIT ZERO..NEWA DIGIT NINE - {0x1145E, 0x1145E, prExtend}, // Mn NEWA SANDHI MARK - {0x1145F, 0x11461, prALetter}, // Lo [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA - {0x11480, 0x114AF, prALetter}, // Lo [48] TIRHUTA ANJI..TIRHUTA LETTER HA - {0x114B0, 0x114B2, prExtend}, // Mc [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II - {0x114B3, 0x114B8, prExtend}, // Mn [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL - {0x114B9, 0x114B9, prExtend}, // Mc TIRHUTA VOWEL SIGN E - {0x114BA, 0x114BA, prExtend}, // Mn TIRHUTA VOWEL SIGN SHORT E - {0x114BB, 0x114BE, prExtend}, // Mc [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU - {0x114BF, 0x114C0, prExtend}, // Mn [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA - {0x114C1, 0x114C1, prExtend}, // Mc TIRHUTA SIGN VISARGA - {0x114C2, 0x114C3, prExtend}, // Mn [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA - {0x114C4, 0x114C5, prALetter}, // Lo [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG - {0x114C7, 0x114C7, prALetter}, // Lo TIRHUTA OM - {0x114D0, 0x114D9, prNumeric}, // Nd [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE - {0x11580, 0x115AE, prALetter}, // Lo [47] SIDDHAM LETTER A..SIDDHAM LETTER HA - {0x115AF, 0x115B1, prExtend}, // Mc [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II - {0x115B2, 0x115B5, prExtend}, // Mn [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR - {0x115B8, 0x115BB, prExtend}, // Mc [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU - {0x115BC, 0x115BD, prExtend}, // Mn [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA - {0x115BE, 0x115BE, prExtend}, // Mc SIDDHAM SIGN VISARGA - {0x115BF, 0x115C0, prExtend}, // Mn [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA - {0x115D8, 0x115DB, prALetter}, // Lo [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U - {0x115DC, 0x115DD, prExtend}, // Mn [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU - {0x11600, 0x1162F, prALetter}, // Lo [48] MODI LETTER A..MODI LETTER LLA - {0x11630, 0x11632, prExtend}, // Mc [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II - {0x11633, 0x1163A, prExtend}, // Mn [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI - {0x1163B, 0x1163C, prExtend}, // Mc [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU - {0x1163D, 0x1163D, prExtend}, // Mn MODI SIGN ANUSVARA - {0x1163E, 0x1163E, prExtend}, // Mc MODI SIGN VISARGA - {0x1163F, 0x11640, prExtend}, // Mn [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA - {0x11644, 0x11644, prALetter}, // Lo MODI SIGN HUVA - {0x11650, 0x11659, prNumeric}, // Nd [10] MODI DIGIT ZERO..MODI DIGIT NINE - {0x11680, 0x116AA, prALetter}, // Lo [43] TAKRI LETTER A..TAKRI LETTER RRA - {0x116AB, 0x116AB, prExtend}, // Mn TAKRI SIGN ANUSVARA - {0x116AC, 0x116AC, prExtend}, // Mc TAKRI SIGN VISARGA - {0x116AD, 0x116AD, prExtend}, // Mn TAKRI VOWEL SIGN AA - {0x116AE, 0x116AF, prExtend}, // Mc [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II - {0x116B0, 0x116B5, prExtend}, // Mn [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU - {0x116B6, 0x116B6, prExtend}, // Mc TAKRI SIGN VIRAMA - {0x116B7, 0x116B7, prExtend}, // Mn TAKRI SIGN NUKTA - {0x116B8, 0x116B8, prALetter}, // Lo TAKRI LETTER ARCHAIC KHA - {0x116C0, 0x116C9, prNumeric}, // Nd [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE - {0x1171D, 0x1171F, prExtend}, // Mn [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA - {0x11720, 0x11721, prExtend}, // Mc [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA - {0x11722, 0x11725, prExtend}, // Mn [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU - {0x11726, 0x11726, prExtend}, // Mc AHOM VOWEL SIGN E - {0x11727, 0x1172B, prExtend}, // Mn [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER - {0x11730, 0x11739, prNumeric}, // Nd [10] AHOM DIGIT ZERO..AHOM DIGIT NINE - {0x11800, 0x1182B, prALetter}, // Lo [44] DOGRA LETTER A..DOGRA LETTER RRA - {0x1182C, 0x1182E, prExtend}, // Mc [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II - {0x1182F, 0x11837, prExtend}, // Mn [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA - {0x11838, 0x11838, prExtend}, // Mc DOGRA SIGN VISARGA - {0x11839, 0x1183A, prExtend}, // Mn [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA - {0x118A0, 0x118DF, prALetter}, // L& [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO - {0x118E0, 0x118E9, prNumeric}, // Nd [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE - {0x118FF, 0x11906, prALetter}, // Lo [8] WARANG CITI OM..DIVES AKURU LETTER E - {0x11909, 0x11909, prALetter}, // Lo DIVES AKURU LETTER O - {0x1190C, 0x11913, prALetter}, // Lo [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA - {0x11915, 0x11916, prALetter}, // Lo [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA - {0x11918, 0x1192F, prALetter}, // Lo [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA - {0x11930, 0x11935, prExtend}, // Mc [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E - {0x11937, 0x11938, prExtend}, // Mc [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O - {0x1193B, 0x1193C, prExtend}, // Mn [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU - {0x1193D, 0x1193D, prExtend}, // Mc DIVES AKURU SIGN HALANTA - {0x1193E, 0x1193E, prExtend}, // Mn DIVES AKURU VIRAMA - {0x1193F, 0x1193F, prALetter}, // Lo DIVES AKURU PREFIXED NASAL SIGN - {0x11940, 0x11940, prExtend}, // Mc DIVES AKURU MEDIAL YA - {0x11941, 0x11941, prALetter}, // Lo DIVES AKURU INITIAL RA - {0x11942, 0x11942, prExtend}, // Mc DIVES AKURU MEDIAL RA - {0x11943, 0x11943, prExtend}, // Mn DIVES AKURU SIGN NUKTA - {0x11950, 0x11959, prNumeric}, // Nd [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE - {0x119A0, 0x119A7, prALetter}, // Lo [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR - {0x119AA, 0x119D0, prALetter}, // Lo [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA - {0x119D1, 0x119D3, prExtend}, // Mc [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II - {0x119D4, 0x119D7, prExtend}, // Mn [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR - {0x119DA, 0x119DB, prExtend}, // Mn [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI - {0x119DC, 0x119DF, prExtend}, // Mc [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA - {0x119E0, 0x119E0, prExtend}, // Mn NANDINAGARI SIGN VIRAMA - {0x119E1, 0x119E1, prALetter}, // Lo NANDINAGARI SIGN AVAGRAHA - {0x119E3, 0x119E3, prALetter}, // Lo NANDINAGARI HEADSTROKE - {0x119E4, 0x119E4, prExtend}, // Mc NANDINAGARI VOWEL SIGN PRISHTHAMATRA E - {0x11A00, 0x11A00, prALetter}, // Lo ZANABAZAR SQUARE LETTER A - {0x11A01, 0x11A0A, prExtend}, // Mn [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK - {0x11A0B, 0x11A32, prALetter}, // Lo [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA - {0x11A33, 0x11A38, prExtend}, // Mn [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA - {0x11A39, 0x11A39, prExtend}, // Mc ZANABAZAR SQUARE SIGN VISARGA - {0x11A3A, 0x11A3A, prALetter}, // Lo ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA - {0x11A3B, 0x11A3E, prExtend}, // Mn [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA - {0x11A47, 0x11A47, prExtend}, // Mn ZANABAZAR SQUARE SUBJOINER - {0x11A50, 0x11A50, prALetter}, // Lo SOYOMBO LETTER A - {0x11A51, 0x11A56, prExtend}, // Mn [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE - {0x11A57, 0x11A58, prExtend}, // Mc [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU - {0x11A59, 0x11A5B, prExtend}, // Mn [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK - {0x11A5C, 0x11A89, prALetter}, // Lo [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA - {0x11A8A, 0x11A96, prExtend}, // Mn [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA - {0x11A97, 0x11A97, prExtend}, // Mc SOYOMBO SIGN VISARGA - {0x11A98, 0x11A99, prExtend}, // Mn [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER - {0x11A9D, 0x11A9D, prALetter}, // Lo SOYOMBO MARK PLUTA - {0x11AB0, 0x11AF8, prALetter}, // Lo [73] CANADIAN SYLLABICS NATTILIK HI..PAU CIN HAU GLOTTAL STOP FINAL - {0x11C00, 0x11C08, prALetter}, // Lo [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L - {0x11C0A, 0x11C2E, prALetter}, // Lo [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA - {0x11C2F, 0x11C2F, prExtend}, // Mc BHAIKSUKI VOWEL SIGN AA - {0x11C30, 0x11C36, prExtend}, // Mn [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L - {0x11C38, 0x11C3D, prExtend}, // Mn [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA - {0x11C3E, 0x11C3E, prExtend}, // Mc BHAIKSUKI SIGN VISARGA - {0x11C3F, 0x11C3F, prExtend}, // Mn BHAIKSUKI SIGN VIRAMA - {0x11C40, 0x11C40, prALetter}, // Lo BHAIKSUKI SIGN AVAGRAHA - {0x11C50, 0x11C59, prNumeric}, // Nd [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE - {0x11C72, 0x11C8F, prALetter}, // Lo [30] MARCHEN LETTER KA..MARCHEN LETTER A - {0x11C92, 0x11CA7, prExtend}, // Mn [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA - {0x11CA9, 0x11CA9, prExtend}, // Mc MARCHEN SUBJOINED LETTER YA - {0x11CAA, 0x11CB0, prExtend}, // Mn [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA - {0x11CB1, 0x11CB1, prExtend}, // Mc MARCHEN VOWEL SIGN I - {0x11CB2, 0x11CB3, prExtend}, // Mn [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E - {0x11CB4, 0x11CB4, prExtend}, // Mc MARCHEN VOWEL SIGN O - {0x11CB5, 0x11CB6, prExtend}, // Mn [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU - {0x11D00, 0x11D06, prALetter}, // Lo [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E - {0x11D08, 0x11D09, prALetter}, // Lo [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O - {0x11D0B, 0x11D30, prALetter}, // Lo [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA - {0x11D31, 0x11D36, prExtend}, // Mn [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R - {0x11D3A, 0x11D3A, prExtend}, // Mn MASARAM GONDI VOWEL SIGN E - {0x11D3C, 0x11D3D, prExtend}, // Mn [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O - {0x11D3F, 0x11D45, prExtend}, // Mn [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA - {0x11D46, 0x11D46, prALetter}, // Lo MASARAM GONDI REPHA - {0x11D47, 0x11D47, prExtend}, // Mn MASARAM GONDI RA-KARA - {0x11D50, 0x11D59, prNumeric}, // Nd [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE - {0x11D60, 0x11D65, prALetter}, // Lo [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU - {0x11D67, 0x11D68, prALetter}, // Lo [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI - {0x11D6A, 0x11D89, prALetter}, // Lo [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA - {0x11D8A, 0x11D8E, prExtend}, // Mc [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU - {0x11D90, 0x11D91, prExtend}, // Mn [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI - {0x11D93, 0x11D94, prExtend}, // Mc [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU - {0x11D95, 0x11D95, prExtend}, // Mn GUNJALA GONDI SIGN ANUSVARA - {0x11D96, 0x11D96, prExtend}, // Mc GUNJALA GONDI SIGN VISARGA - {0x11D97, 0x11D97, prExtend}, // Mn GUNJALA GONDI VIRAMA - {0x11D98, 0x11D98, prALetter}, // Lo GUNJALA GONDI OM - {0x11DA0, 0x11DA9, prNumeric}, // Nd [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE - {0x11EE0, 0x11EF2, prALetter}, // Lo [19] MAKASAR LETTER KA..MAKASAR ANGKA - {0x11EF3, 0x11EF4, prExtend}, // Mn [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U - {0x11EF5, 0x11EF6, prExtend}, // Mc [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O - {0x11F00, 0x11F01, prExtend}, // Mn [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA - {0x11F02, 0x11F02, prALetter}, // Lo KAWI SIGN REPHA - {0x11F03, 0x11F03, prExtend}, // Mc KAWI SIGN VISARGA - {0x11F04, 0x11F10, prALetter}, // Lo [13] KAWI LETTER A..KAWI LETTER O - {0x11F12, 0x11F33, prALetter}, // Lo [34] KAWI LETTER KA..KAWI LETTER JNYA - {0x11F34, 0x11F35, prExtend}, // Mc [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA - {0x11F36, 0x11F3A, prExtend}, // Mn [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R - {0x11F3E, 0x11F3F, prExtend}, // Mc [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI - {0x11F40, 0x11F40, prExtend}, // Mn KAWI VOWEL SIGN EU - {0x11F41, 0x11F41, prExtend}, // Mc KAWI SIGN KILLER - {0x11F42, 0x11F42, prExtend}, // Mn KAWI CONJOINER - {0x11F50, 0x11F59, prNumeric}, // Nd [10] KAWI DIGIT ZERO..KAWI DIGIT NINE - {0x11FB0, 0x11FB0, prALetter}, // Lo LISU LETTER YHA - {0x12000, 0x12399, prALetter}, // Lo [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U - {0x12400, 0x1246E, prALetter}, // Nl [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM - {0x12480, 0x12543, prALetter}, // Lo [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU - {0x12F90, 0x12FF0, prALetter}, // Lo [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114 - {0x13000, 0x1342F, prALetter}, // Lo [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D - {0x13430, 0x1343F, prFormat}, // Cf [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE - {0x13440, 0x13440, prExtend}, // Mn EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY - {0x13441, 0x13446, prALetter}, // Lo [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN - {0x13447, 0x13455, prExtend}, // Mn [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED - {0x14400, 0x14646, prALetter}, // Lo [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530 - {0x16800, 0x16A38, prALetter}, // Lo [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ - {0x16A40, 0x16A5E, prALetter}, // Lo [31] MRO LETTER TA..MRO LETTER TEK - {0x16A60, 0x16A69, prNumeric}, // Nd [10] MRO DIGIT ZERO..MRO DIGIT NINE - {0x16A70, 0x16ABE, prALetter}, // Lo [79] TANGSA LETTER OZ..TANGSA LETTER ZA - {0x16AC0, 0x16AC9, prNumeric}, // Nd [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE - {0x16AD0, 0x16AED, prALetter}, // Lo [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I - {0x16AF0, 0x16AF4, prExtend}, // Mn [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE - {0x16B00, 0x16B2F, prALetter}, // Lo [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU - {0x16B30, 0x16B36, prExtend}, // Mn [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM - {0x16B40, 0x16B43, prALetter}, // Lm [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM - {0x16B50, 0x16B59, prNumeric}, // Nd [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE - {0x16B63, 0x16B77, prALetter}, // Lo [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS - {0x16B7D, 0x16B8F, prALetter}, // Lo [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ - {0x16E40, 0x16E7F, prALetter}, // L& [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y - {0x16F00, 0x16F4A, prALetter}, // Lo [75] MIAO LETTER PA..MIAO LETTER RTE - {0x16F4F, 0x16F4F, prExtend}, // Mn MIAO SIGN CONSONANT MODIFIER BAR - {0x16F50, 0x16F50, prALetter}, // Lo MIAO LETTER NASALIZATION - {0x16F51, 0x16F87, prExtend}, // Mc [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI - {0x16F8F, 0x16F92, prExtend}, // Mn [4] MIAO TONE RIGHT..MIAO TONE BELOW - {0x16F93, 0x16F9F, prALetter}, // Lm [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8 - {0x16FE0, 0x16FE1, prALetter}, // Lm [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK - {0x16FE3, 0x16FE3, prALetter}, // Lm OLD CHINESE ITERATION MARK - {0x16FE4, 0x16FE4, prExtend}, // Mn KHITAN SMALL SCRIPT FILLER - {0x16FF0, 0x16FF1, prExtend}, // Mc [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY - {0x1AFF0, 0x1AFF3, prKatakana}, // Lm [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5 - {0x1AFF5, 0x1AFFB, prKatakana}, // Lm [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5 - {0x1AFFD, 0x1AFFE, prKatakana}, // Lm [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8 - {0x1B000, 0x1B000, prKatakana}, // Lo KATAKANA LETTER ARCHAIC E - {0x1B120, 0x1B122, prKatakana}, // Lo [3] KATAKANA LETTER ARCHAIC YI..KATAKANA LETTER ARCHAIC WU - {0x1B155, 0x1B155, prKatakana}, // Lo KATAKANA LETTER SMALL KO - {0x1B164, 0x1B167, prKatakana}, // Lo [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N - {0x1BC00, 0x1BC6A, prALetter}, // Lo [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M - {0x1BC70, 0x1BC7C, prALetter}, // Lo [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK - {0x1BC80, 0x1BC88, prALetter}, // Lo [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL - {0x1BC90, 0x1BC99, prALetter}, // Lo [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW - {0x1BC9D, 0x1BC9E, prExtend}, // Mn [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK - {0x1BCA0, 0x1BCA3, prFormat}, // Cf [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP - {0x1CF00, 0x1CF2D, prExtend}, // Mn [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT - {0x1CF30, 0x1CF46, prExtend}, // Mn [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG - {0x1D165, 0x1D166, prExtend}, // Mc [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM - {0x1D167, 0x1D169, prExtend}, // Mn [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3 - {0x1D16D, 0x1D172, prExtend}, // Mc [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5 - {0x1D173, 0x1D17A, prFormat}, // Cf [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE - {0x1D17B, 0x1D182, prExtend}, // Mn [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE - {0x1D185, 0x1D18B, prExtend}, // Mn [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE - {0x1D1AA, 0x1D1AD, prExtend}, // Mn [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO - {0x1D242, 0x1D244, prExtend}, // Mn [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME - {0x1D400, 0x1D454, prALetter}, // L& [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G - {0x1D456, 0x1D49C, prALetter}, // L& [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A - {0x1D49E, 0x1D49F, prALetter}, // L& [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D - {0x1D4A2, 0x1D4A2, prALetter}, // L& MATHEMATICAL SCRIPT CAPITAL G - {0x1D4A5, 0x1D4A6, prALetter}, // L& [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K - {0x1D4A9, 0x1D4AC, prALetter}, // L& [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q - {0x1D4AE, 0x1D4B9, prALetter}, // L& [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D - {0x1D4BB, 0x1D4BB, prALetter}, // L& MATHEMATICAL SCRIPT SMALL F - {0x1D4BD, 0x1D4C3, prALetter}, // L& [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N - {0x1D4C5, 0x1D505, prALetter}, // L& [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B - {0x1D507, 0x1D50A, prALetter}, // L& [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G - {0x1D50D, 0x1D514, prALetter}, // L& [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q - {0x1D516, 0x1D51C, prALetter}, // L& [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y - {0x1D51E, 0x1D539, prALetter}, // L& [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B - {0x1D53B, 0x1D53E, prALetter}, // L& [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G - {0x1D540, 0x1D544, prALetter}, // L& [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M - {0x1D546, 0x1D546, prALetter}, // L& MATHEMATICAL DOUBLE-STRUCK CAPITAL O - {0x1D54A, 0x1D550, prALetter}, // L& [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y - {0x1D552, 0x1D6A5, prALetter}, // L& [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J - {0x1D6A8, 0x1D6C0, prALetter}, // L& [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA - {0x1D6C2, 0x1D6DA, prALetter}, // L& [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA - {0x1D6DC, 0x1D6FA, prALetter}, // L& [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA - {0x1D6FC, 0x1D714, prALetter}, // L& [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA - {0x1D716, 0x1D734, prALetter}, // L& [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA - {0x1D736, 0x1D74E, prALetter}, // L& [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA - {0x1D750, 0x1D76E, prALetter}, // L& [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA - {0x1D770, 0x1D788, prALetter}, // L& [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA - {0x1D78A, 0x1D7A8, prALetter}, // L& [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA - {0x1D7AA, 0x1D7C2, prALetter}, // L& [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA - {0x1D7C4, 0x1D7CB, prALetter}, // L& [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA - {0x1D7CE, 0x1D7FF, prNumeric}, // Nd [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE - {0x1DA00, 0x1DA36, prExtend}, // Mn [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN - {0x1DA3B, 0x1DA6C, prExtend}, // Mn [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT - {0x1DA75, 0x1DA75, prExtend}, // Mn SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS - {0x1DA84, 0x1DA84, prExtend}, // Mn SIGNWRITING LOCATION HEAD NECK - {0x1DA9B, 0x1DA9F, prExtend}, // Mn [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6 - {0x1DAA1, 0x1DAAF, prExtend}, // Mn [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16 - {0x1DF00, 0x1DF09, prALetter}, // L& [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK - {0x1DF0A, 0x1DF0A, prALetter}, // Lo LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK - {0x1DF0B, 0x1DF1E, prALetter}, // L& [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL - {0x1DF25, 0x1DF2A, prALetter}, // L& [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK - {0x1E000, 0x1E006, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE - {0x1E008, 0x1E018, prExtend}, // Mn [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU - {0x1E01B, 0x1E021, prExtend}, // Mn [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI - {0x1E023, 0x1E024, prExtend}, // Mn [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS - {0x1E026, 0x1E02A, prExtend}, // Mn [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA - {0x1E030, 0x1E06D, prALetter}, // Lm [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE - {0x1E08F, 0x1E08F, prExtend}, // Mn COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I - {0x1E100, 0x1E12C, prALetter}, // Lo [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W - {0x1E130, 0x1E136, prExtend}, // Mn [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D - {0x1E137, 0x1E13D, prALetter}, // Lm [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER - {0x1E140, 0x1E149, prNumeric}, // Nd [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE - {0x1E14E, 0x1E14E, prALetter}, // Lo NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ - {0x1E290, 0x1E2AD, prALetter}, // Lo [30] TOTO LETTER PA..TOTO LETTER A - {0x1E2AE, 0x1E2AE, prExtend}, // Mn TOTO SIGN RISING TONE - {0x1E2C0, 0x1E2EB, prALetter}, // Lo [44] WANCHO LETTER AA..WANCHO LETTER YIH - {0x1E2EC, 0x1E2EF, prExtend}, // Mn [4] WANCHO TONE TUP..WANCHO TONE KOINI - {0x1E2F0, 0x1E2F9, prNumeric}, // Nd [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE - {0x1E4D0, 0x1E4EA, prALetter}, // Lo [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL - {0x1E4EB, 0x1E4EB, prALetter}, // Lm NAG MUNDARI SIGN OJOD - {0x1E4EC, 0x1E4EF, prExtend}, // Mn [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH - {0x1E4F0, 0x1E4F9, prNumeric}, // Nd [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE - {0x1E7E0, 0x1E7E6, prALetter}, // Lo [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO - {0x1E7E8, 0x1E7EB, prALetter}, // Lo [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE - {0x1E7ED, 0x1E7EE, prALetter}, // Lo [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE - {0x1E7F0, 0x1E7FE, prALetter}, // Lo [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE - {0x1E800, 0x1E8C4, prALetter}, // Lo [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON - {0x1E8D0, 0x1E8D6, prExtend}, // Mn [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS - {0x1E900, 0x1E943, prALetter}, // L& [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA - {0x1E944, 0x1E94A, prExtend}, // Mn [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA - {0x1E94B, 0x1E94B, prALetter}, // Lm ADLAM NASALIZATION MARK - {0x1E950, 0x1E959, prNumeric}, // Nd [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE - {0x1EE00, 0x1EE03, prALetter}, // Lo [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL - {0x1EE05, 0x1EE1F, prALetter}, // Lo [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF - {0x1EE21, 0x1EE22, prALetter}, // Lo [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM - {0x1EE24, 0x1EE24, prALetter}, // Lo ARABIC MATHEMATICAL INITIAL HEH - {0x1EE27, 0x1EE27, prALetter}, // Lo ARABIC MATHEMATICAL INITIAL HAH - {0x1EE29, 0x1EE32, prALetter}, // Lo [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF - {0x1EE34, 0x1EE37, prALetter}, // Lo [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH - {0x1EE39, 0x1EE39, prALetter}, // Lo ARABIC MATHEMATICAL INITIAL DAD - {0x1EE3B, 0x1EE3B, prALetter}, // Lo ARABIC MATHEMATICAL INITIAL GHAIN - {0x1EE42, 0x1EE42, prALetter}, // Lo ARABIC MATHEMATICAL TAILED JEEM - {0x1EE47, 0x1EE47, prALetter}, // Lo ARABIC MATHEMATICAL TAILED HAH - {0x1EE49, 0x1EE49, prALetter}, // Lo ARABIC MATHEMATICAL TAILED YEH - {0x1EE4B, 0x1EE4B, prALetter}, // Lo ARABIC MATHEMATICAL TAILED LAM - {0x1EE4D, 0x1EE4F, prALetter}, // Lo [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN - {0x1EE51, 0x1EE52, prALetter}, // Lo [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF - {0x1EE54, 0x1EE54, prALetter}, // Lo ARABIC MATHEMATICAL TAILED SHEEN - {0x1EE57, 0x1EE57, prALetter}, // Lo ARABIC MATHEMATICAL TAILED KHAH - {0x1EE59, 0x1EE59, prALetter}, // Lo ARABIC MATHEMATICAL TAILED DAD - {0x1EE5B, 0x1EE5B, prALetter}, // Lo ARABIC MATHEMATICAL TAILED GHAIN - {0x1EE5D, 0x1EE5D, prALetter}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS NOON - {0x1EE5F, 0x1EE5F, prALetter}, // Lo ARABIC MATHEMATICAL TAILED DOTLESS QAF - {0x1EE61, 0x1EE62, prALetter}, // Lo [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM - {0x1EE64, 0x1EE64, prALetter}, // Lo ARABIC MATHEMATICAL STRETCHED HEH - {0x1EE67, 0x1EE6A, prALetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF - {0x1EE6C, 0x1EE72, prALetter}, // Lo [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF - {0x1EE74, 0x1EE77, prALetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH - {0x1EE79, 0x1EE7C, prALetter}, // Lo [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH - {0x1EE7E, 0x1EE7E, prALetter}, // Lo ARABIC MATHEMATICAL STRETCHED DOTLESS FEH - {0x1EE80, 0x1EE89, prALetter}, // Lo [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH - {0x1EE8B, 0x1EE9B, prALetter}, // Lo [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN - {0x1EEA1, 0x1EEA3, prALetter}, // Lo [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL - {0x1EEA5, 0x1EEA9, prALetter}, // Lo [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH - {0x1EEAB, 0x1EEBB, prALetter}, // Lo [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN - {0x1F000, 0x1F003, prExtendedPictographic}, // E0.0 [4] (🀀..🀃) MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND - {0x1F004, 0x1F004, prExtendedPictographic}, // E0.6 [1] (🀄) mahjong red dragon - {0x1F005, 0x1F0CE, prExtendedPictographic}, // E0.0 [202] (🀅..🃎) MAHJONG TILE GREEN DRAGON..PLAYING CARD KING OF DIAMONDS - {0x1F0CF, 0x1F0CF, prExtendedPictographic}, // E0.6 [1] (🃏) joker - {0x1F0D0, 0x1F0FF, prExtendedPictographic}, // E0.0 [48] (🃐..🃿) .. - {0x1F10D, 0x1F10F, prExtendedPictographic}, // E0.0 [3] (🄍..🄏) CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH - {0x1F12F, 0x1F12F, prExtendedPictographic}, // E0.0 [1] (🄯) COPYLEFT SYMBOL - {0x1F130, 0x1F149, prALetter}, // So [26] SQUARED LATIN CAPITAL LETTER A..SQUARED LATIN CAPITAL LETTER Z - {0x1F150, 0x1F169, prALetter}, // So [26] NEGATIVE CIRCLED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z - {0x1F16C, 0x1F16F, prExtendedPictographic}, // E0.0 [4] (🅬..🅯) RAISED MR SIGN..CIRCLED HUMAN FIGURE - {0x1F170, 0x1F189, prALetter}, // So [26] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED LATIN CAPITAL LETTER Z - {0x1F170, 0x1F171, prExtendedPictographic}, // E0.6 [2] (🅰️..🅱️) A button (blood type)..B button (blood type) - {0x1F17E, 0x1F17F, prExtendedPictographic}, // E0.6 [2] (🅾️..🅿️) O button (blood type)..P button - {0x1F18E, 0x1F18E, prExtendedPictographic}, // E0.6 [1] (🆎) AB button (blood type) - {0x1F191, 0x1F19A, prExtendedPictographic}, // E0.6 [10] (🆑..🆚) CL button..VS button - {0x1F1AD, 0x1F1E5, prExtendedPictographic}, // E0.0 [57] (🆭..🇥) MASK WORK SYMBOL.. - {0x1F1E6, 0x1F1FF, prRegionalIndicator}, // So [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z - {0x1F201, 0x1F202, prExtendedPictographic}, // E0.6 [2] (🈁..🈂️) Japanese “here” button..Japanese “service charge” button - {0x1F203, 0x1F20F, prExtendedPictographic}, // E0.0 [13] (🈃..🈏) .. - {0x1F21A, 0x1F21A, prExtendedPictographic}, // E0.6 [1] (🈚) Japanese “free of charge” button - {0x1F22F, 0x1F22F, prExtendedPictographic}, // E0.6 [1] (🈯) Japanese “reserved” button - {0x1F232, 0x1F23A, prExtendedPictographic}, // E0.6 [9] (🈲..🈺) Japanese “prohibited” button..Japanese “open for business” button - {0x1F23C, 0x1F23F, prExtendedPictographic}, // E0.0 [4] (🈼..🈿) .. - {0x1F249, 0x1F24F, prExtendedPictographic}, // E0.0 [7] (🉉..🉏) .. - {0x1F250, 0x1F251, prExtendedPictographic}, // E0.6 [2] (🉐..🉑) Japanese “bargain” button..Japanese “acceptable” button - {0x1F252, 0x1F2FF, prExtendedPictographic}, // E0.0 [174] (🉒..🋿) .. - {0x1F300, 0x1F30C, prExtendedPictographic}, // E0.6 [13] (🌀..🌌) cyclone..milky way - {0x1F30D, 0x1F30E, prExtendedPictographic}, // E0.7 [2] (🌍..🌎) globe showing Europe-Africa..globe showing Americas - {0x1F30F, 0x1F30F, prExtendedPictographic}, // E0.6 [1] (🌏) globe showing Asia-Australia - {0x1F310, 0x1F310, prExtendedPictographic}, // E1.0 [1] (🌐) globe with meridians - {0x1F311, 0x1F311, prExtendedPictographic}, // E0.6 [1] (🌑) new moon - {0x1F312, 0x1F312, prExtendedPictographic}, // E1.0 [1] (🌒) waxing crescent moon - {0x1F313, 0x1F315, prExtendedPictographic}, // E0.6 [3] (🌓..🌕) first quarter moon..full moon - {0x1F316, 0x1F318, prExtendedPictographic}, // E1.0 [3] (🌖..🌘) waning gibbous moon..waning crescent moon - {0x1F319, 0x1F319, prExtendedPictographic}, // E0.6 [1] (🌙) crescent moon - {0x1F31A, 0x1F31A, prExtendedPictographic}, // E1.0 [1] (🌚) new moon face - {0x1F31B, 0x1F31B, prExtendedPictographic}, // E0.6 [1] (🌛) first quarter moon face - {0x1F31C, 0x1F31C, prExtendedPictographic}, // E0.7 [1] (🌜) last quarter moon face - {0x1F31D, 0x1F31E, prExtendedPictographic}, // E1.0 [2] (🌝..🌞) full moon face..sun with face - {0x1F31F, 0x1F320, prExtendedPictographic}, // E0.6 [2] (🌟..🌠) glowing star..shooting star - {0x1F321, 0x1F321, prExtendedPictographic}, // E0.7 [1] (🌡️) thermometer - {0x1F322, 0x1F323, prExtendedPictographic}, // E0.0 [2] (🌢..🌣) BLACK DROPLET..WHITE SUN - {0x1F324, 0x1F32C, prExtendedPictographic}, // E0.7 [9] (🌤️..🌬️) sun behind small cloud..wind face - {0x1F32D, 0x1F32F, prExtendedPictographic}, // E1.0 [3] (🌭..🌯) hot dog..burrito - {0x1F330, 0x1F331, prExtendedPictographic}, // E0.6 [2] (🌰..🌱) chestnut..seedling - {0x1F332, 0x1F333, prExtendedPictographic}, // E1.0 [2] (🌲..🌳) evergreen tree..deciduous tree - {0x1F334, 0x1F335, prExtendedPictographic}, // E0.6 [2] (🌴..🌵) palm tree..cactus - {0x1F336, 0x1F336, prExtendedPictographic}, // E0.7 [1] (🌶️) hot pepper - {0x1F337, 0x1F34A, prExtendedPictographic}, // E0.6 [20] (🌷..🍊) tulip..tangerine - {0x1F34B, 0x1F34B, prExtendedPictographic}, // E1.0 [1] (🍋) lemon - {0x1F34C, 0x1F34F, prExtendedPictographic}, // E0.6 [4] (🍌..🍏) banana..green apple - {0x1F350, 0x1F350, prExtendedPictographic}, // E1.0 [1] (🍐) pear - {0x1F351, 0x1F37B, prExtendedPictographic}, // E0.6 [43] (🍑..🍻) peach..clinking beer mugs - {0x1F37C, 0x1F37C, prExtendedPictographic}, // E1.0 [1] (🍼) baby bottle - {0x1F37D, 0x1F37D, prExtendedPictographic}, // E0.7 [1] (🍽️) fork and knife with plate - {0x1F37E, 0x1F37F, prExtendedPictographic}, // E1.0 [2] (🍾..🍿) bottle with popping cork..popcorn - {0x1F380, 0x1F393, prExtendedPictographic}, // E0.6 [20] (🎀..🎓) ribbon..graduation cap - {0x1F394, 0x1F395, prExtendedPictographic}, // E0.0 [2] (🎔..🎕) HEART WITH TIP ON THE LEFT..BOUQUET OF FLOWERS - {0x1F396, 0x1F397, prExtendedPictographic}, // E0.7 [2] (🎖️..🎗️) military medal..reminder ribbon - {0x1F398, 0x1F398, prExtendedPictographic}, // E0.0 [1] (🎘) MUSICAL KEYBOARD WITH JACKS - {0x1F399, 0x1F39B, prExtendedPictographic}, // E0.7 [3] (🎙️..🎛️) studio microphone..control knobs - {0x1F39C, 0x1F39D, prExtendedPictographic}, // E0.0 [2] (🎜..🎝) BEAMED ASCENDING MUSICAL NOTES..BEAMED DESCENDING MUSICAL NOTES - {0x1F39E, 0x1F39F, prExtendedPictographic}, // E0.7 [2] (🎞️..🎟️) film frames..admission tickets - {0x1F3A0, 0x1F3C4, prExtendedPictographic}, // E0.6 [37] (🎠..🏄) carousel horse..person surfing - {0x1F3C5, 0x1F3C5, prExtendedPictographic}, // E1.0 [1] (🏅) sports medal - {0x1F3C6, 0x1F3C6, prExtendedPictographic}, // E0.6 [1] (🏆) trophy - {0x1F3C7, 0x1F3C7, prExtendedPictographic}, // E1.0 [1] (🏇) horse racing - {0x1F3C8, 0x1F3C8, prExtendedPictographic}, // E0.6 [1] (🏈) american football - {0x1F3C9, 0x1F3C9, prExtendedPictographic}, // E1.0 [1] (🏉) rugby football - {0x1F3CA, 0x1F3CA, prExtendedPictographic}, // E0.6 [1] (🏊) person swimming - {0x1F3CB, 0x1F3CE, prExtendedPictographic}, // E0.7 [4] (🏋️..🏎️) person lifting weights..racing car - {0x1F3CF, 0x1F3D3, prExtendedPictographic}, // E1.0 [5] (🏏..🏓) cricket game..ping pong - {0x1F3D4, 0x1F3DF, prExtendedPictographic}, // E0.7 [12] (🏔️..🏟️) snow-capped mountain..stadium - {0x1F3E0, 0x1F3E3, prExtendedPictographic}, // E0.6 [4] (🏠..🏣) house..Japanese post office - {0x1F3E4, 0x1F3E4, prExtendedPictographic}, // E1.0 [1] (🏤) post office - {0x1F3E5, 0x1F3F0, prExtendedPictographic}, // E0.6 [12] (🏥..🏰) hospital..castle - {0x1F3F1, 0x1F3F2, prExtendedPictographic}, // E0.0 [2] (🏱..🏲) WHITE PENNANT..BLACK PENNANT - {0x1F3F3, 0x1F3F3, prExtendedPictographic}, // E0.7 [1] (🏳️) white flag - {0x1F3F4, 0x1F3F4, prExtendedPictographic}, // E1.0 [1] (🏴) black flag - {0x1F3F5, 0x1F3F5, prExtendedPictographic}, // E0.7 [1] (🏵️) rosette - {0x1F3F6, 0x1F3F6, prExtendedPictographic}, // E0.0 [1] (🏶) BLACK ROSETTE - {0x1F3F7, 0x1F3F7, prExtendedPictographic}, // E0.7 [1] (🏷️) label - {0x1F3F8, 0x1F3FA, prExtendedPictographic}, // E1.0 [3] (🏸..🏺) badminton..amphora - {0x1F3FB, 0x1F3FF, prExtend}, // Sk [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6 - {0x1F400, 0x1F407, prExtendedPictographic}, // E1.0 [8] (🐀..🐇) rat..rabbit - {0x1F408, 0x1F408, prExtendedPictographic}, // E0.7 [1] (🐈) cat - {0x1F409, 0x1F40B, prExtendedPictographic}, // E1.0 [3] (🐉..🐋) dragon..whale - {0x1F40C, 0x1F40E, prExtendedPictographic}, // E0.6 [3] (🐌..🐎) snail..horse - {0x1F40F, 0x1F410, prExtendedPictographic}, // E1.0 [2] (🐏..🐐) ram..goat - {0x1F411, 0x1F412, prExtendedPictographic}, // E0.6 [2] (🐑..🐒) ewe..monkey - {0x1F413, 0x1F413, prExtendedPictographic}, // E1.0 [1] (🐓) rooster - {0x1F414, 0x1F414, prExtendedPictographic}, // E0.6 [1] (🐔) chicken - {0x1F415, 0x1F415, prExtendedPictographic}, // E0.7 [1] (🐕) dog - {0x1F416, 0x1F416, prExtendedPictographic}, // E1.0 [1] (🐖) pig - {0x1F417, 0x1F429, prExtendedPictographic}, // E0.6 [19] (🐗..🐩) boar..poodle - {0x1F42A, 0x1F42A, prExtendedPictographic}, // E1.0 [1] (🐪) camel - {0x1F42B, 0x1F43E, prExtendedPictographic}, // E0.6 [20] (🐫..🐾) two-hump camel..paw prints - {0x1F43F, 0x1F43F, prExtendedPictographic}, // E0.7 [1] (🐿️) chipmunk - {0x1F440, 0x1F440, prExtendedPictographic}, // E0.6 [1] (👀) eyes - {0x1F441, 0x1F441, prExtendedPictographic}, // E0.7 [1] (👁️) eye - {0x1F442, 0x1F464, prExtendedPictographic}, // E0.6 [35] (👂..👤) ear..bust in silhouette - {0x1F465, 0x1F465, prExtendedPictographic}, // E1.0 [1] (👥) busts in silhouette - {0x1F466, 0x1F46B, prExtendedPictographic}, // E0.6 [6] (👦..👫) boy..woman and man holding hands - {0x1F46C, 0x1F46D, prExtendedPictographic}, // E1.0 [2] (👬..👭) men holding hands..women holding hands - {0x1F46E, 0x1F4AC, prExtendedPictographic}, // E0.6 [63] (👮..💬) police officer..speech balloon - {0x1F4AD, 0x1F4AD, prExtendedPictographic}, // E1.0 [1] (💭) thought balloon - {0x1F4AE, 0x1F4B5, prExtendedPictographic}, // E0.6 [8] (💮..💵) white flower..dollar banknote - {0x1F4B6, 0x1F4B7, prExtendedPictographic}, // E1.0 [2] (💶..💷) euro banknote..pound banknote - {0x1F4B8, 0x1F4EB, prExtendedPictographic}, // E0.6 [52] (💸..📫) money with wings..closed mailbox with raised flag - {0x1F4EC, 0x1F4ED, prExtendedPictographic}, // E0.7 [2] (📬..📭) open mailbox with raised flag..open mailbox with lowered flag - {0x1F4EE, 0x1F4EE, prExtendedPictographic}, // E0.6 [1] (📮) postbox - {0x1F4EF, 0x1F4EF, prExtendedPictographic}, // E1.0 [1] (📯) postal horn - {0x1F4F0, 0x1F4F4, prExtendedPictographic}, // E0.6 [5] (📰..📴) newspaper..mobile phone off - {0x1F4F5, 0x1F4F5, prExtendedPictographic}, // E1.0 [1] (📵) no mobile phones - {0x1F4F6, 0x1F4F7, prExtendedPictographic}, // E0.6 [2] (📶..📷) antenna bars..camera - {0x1F4F8, 0x1F4F8, prExtendedPictographic}, // E1.0 [1] (📸) camera with flash - {0x1F4F9, 0x1F4FC, prExtendedPictographic}, // E0.6 [4] (📹..📼) video camera..videocassette - {0x1F4FD, 0x1F4FD, prExtendedPictographic}, // E0.7 [1] (📽️) film projector - {0x1F4FE, 0x1F4FE, prExtendedPictographic}, // E0.0 [1] (📾) PORTABLE STEREO - {0x1F4FF, 0x1F502, prExtendedPictographic}, // E1.0 [4] (📿..🔂) prayer beads..repeat single button - {0x1F503, 0x1F503, prExtendedPictographic}, // E0.6 [1] (🔃) clockwise vertical arrows - {0x1F504, 0x1F507, prExtendedPictographic}, // E1.0 [4] (🔄..🔇) counterclockwise arrows button..muted speaker - {0x1F508, 0x1F508, prExtendedPictographic}, // E0.7 [1] (🔈) speaker low volume - {0x1F509, 0x1F509, prExtendedPictographic}, // E1.0 [1] (🔉) speaker medium volume - {0x1F50A, 0x1F514, prExtendedPictographic}, // E0.6 [11] (🔊..🔔) speaker high volume..bell - {0x1F515, 0x1F515, prExtendedPictographic}, // E1.0 [1] (🔕) bell with slash - {0x1F516, 0x1F52B, prExtendedPictographic}, // E0.6 [22] (🔖..🔫) bookmark..water pistol - {0x1F52C, 0x1F52D, prExtendedPictographic}, // E1.0 [2] (🔬..🔭) microscope..telescope - {0x1F52E, 0x1F53D, prExtendedPictographic}, // E0.6 [16] (🔮..🔽) crystal ball..downwards button - {0x1F546, 0x1F548, prExtendedPictographic}, // E0.0 [3] (🕆..🕈) WHITE LATIN CROSS..CELTIC CROSS - {0x1F549, 0x1F54A, prExtendedPictographic}, // E0.7 [2] (🕉️..🕊️) om..dove - {0x1F54B, 0x1F54E, prExtendedPictographic}, // E1.0 [4] (🕋..🕎) kaaba..menorah - {0x1F54F, 0x1F54F, prExtendedPictographic}, // E0.0 [1] (🕏) BOWL OF HYGIEIA - {0x1F550, 0x1F55B, prExtendedPictographic}, // E0.6 [12] (🕐..🕛) one o’clock..twelve o’clock - {0x1F55C, 0x1F567, prExtendedPictographic}, // E0.7 [12] (🕜..🕧) one-thirty..twelve-thirty - {0x1F568, 0x1F56E, prExtendedPictographic}, // E0.0 [7] (🕨..🕮) RIGHT SPEAKER..BOOK - {0x1F56F, 0x1F570, prExtendedPictographic}, // E0.7 [2] (🕯️..🕰️) candle..mantelpiece clock - {0x1F571, 0x1F572, prExtendedPictographic}, // E0.0 [2] (🕱..🕲) BLACK SKULL AND CROSSBONES..NO PIRACY - {0x1F573, 0x1F579, prExtendedPictographic}, // E0.7 [7] (🕳️..🕹️) hole..joystick - {0x1F57A, 0x1F57A, prExtendedPictographic}, // E3.0 [1] (🕺) man dancing - {0x1F57B, 0x1F586, prExtendedPictographic}, // E0.0 [12] (🕻..🖆) LEFT HAND TELEPHONE RECEIVER..PEN OVER STAMPED ENVELOPE - {0x1F587, 0x1F587, prExtendedPictographic}, // E0.7 [1] (🖇️) linked paperclips - {0x1F588, 0x1F589, prExtendedPictographic}, // E0.0 [2] (🖈..🖉) BLACK PUSHPIN..LOWER LEFT PENCIL - {0x1F58A, 0x1F58D, prExtendedPictographic}, // E0.7 [4] (🖊️..🖍️) pen..crayon - {0x1F58E, 0x1F58F, prExtendedPictographic}, // E0.0 [2] (🖎..🖏) LEFT WRITING HAND..TURNED OK HAND SIGN - {0x1F590, 0x1F590, prExtendedPictographic}, // E0.7 [1] (🖐️) hand with fingers splayed - {0x1F591, 0x1F594, prExtendedPictographic}, // E0.0 [4] (🖑..🖔) REVERSED RAISED HAND WITH FINGERS SPLAYED..REVERSED VICTORY HAND - {0x1F595, 0x1F596, prExtendedPictographic}, // E1.0 [2] (🖕..🖖) middle finger..vulcan salute - {0x1F597, 0x1F5A3, prExtendedPictographic}, // E0.0 [13] (🖗..🖣) WHITE DOWN POINTING LEFT HAND INDEX..BLACK DOWN POINTING BACKHAND INDEX - {0x1F5A4, 0x1F5A4, prExtendedPictographic}, // E3.0 [1] (🖤) black heart - {0x1F5A5, 0x1F5A5, prExtendedPictographic}, // E0.7 [1] (🖥️) desktop computer - {0x1F5A6, 0x1F5A7, prExtendedPictographic}, // E0.0 [2] (🖦..🖧) KEYBOARD AND MOUSE..THREE NETWORKED COMPUTERS - {0x1F5A8, 0x1F5A8, prExtendedPictographic}, // E0.7 [1] (🖨️) printer - {0x1F5A9, 0x1F5B0, prExtendedPictographic}, // E0.0 [8] (🖩..🖰) POCKET CALCULATOR..TWO BUTTON MOUSE - {0x1F5B1, 0x1F5B2, prExtendedPictographic}, // E0.7 [2] (🖱️..🖲️) computer mouse..trackball - {0x1F5B3, 0x1F5BB, prExtendedPictographic}, // E0.0 [9] (🖳..🖻) OLD PERSONAL COMPUTER..DOCUMENT WITH PICTURE - {0x1F5BC, 0x1F5BC, prExtendedPictographic}, // E0.7 [1] (🖼️) framed picture - {0x1F5BD, 0x1F5C1, prExtendedPictographic}, // E0.0 [5] (🖽..🗁) FRAME WITH TILES..OPEN FOLDER - {0x1F5C2, 0x1F5C4, prExtendedPictographic}, // E0.7 [3] (🗂️..🗄️) card index dividers..file cabinet - {0x1F5C5, 0x1F5D0, prExtendedPictographic}, // E0.0 [12] (🗅..🗐) EMPTY NOTE..PAGES - {0x1F5D1, 0x1F5D3, prExtendedPictographic}, // E0.7 [3] (🗑️..🗓️) wastebasket..spiral calendar - {0x1F5D4, 0x1F5DB, prExtendedPictographic}, // E0.0 [8] (🗔..🗛) DESKTOP WINDOW..DECREASE FONT SIZE SYMBOL - {0x1F5DC, 0x1F5DE, prExtendedPictographic}, // E0.7 [3] (🗜️..🗞️) clamp..rolled-up newspaper - {0x1F5DF, 0x1F5E0, prExtendedPictographic}, // E0.0 [2] (🗟..🗠) PAGE WITH CIRCLED TEXT..STOCK CHART - {0x1F5E1, 0x1F5E1, prExtendedPictographic}, // E0.7 [1] (🗡️) dagger - {0x1F5E2, 0x1F5E2, prExtendedPictographic}, // E0.0 [1] (🗢) LIPS - {0x1F5E3, 0x1F5E3, prExtendedPictographic}, // E0.7 [1] (🗣️) speaking head - {0x1F5E4, 0x1F5E7, prExtendedPictographic}, // E0.0 [4] (🗤..🗧) THREE RAYS ABOVE..THREE RAYS RIGHT - {0x1F5E8, 0x1F5E8, prExtendedPictographic}, // E2.0 [1] (🗨️) left speech bubble - {0x1F5E9, 0x1F5EE, prExtendedPictographic}, // E0.0 [6] (🗩..🗮) RIGHT SPEECH BUBBLE..LEFT ANGER BUBBLE - {0x1F5EF, 0x1F5EF, prExtendedPictographic}, // E0.7 [1] (🗯️) right anger bubble - {0x1F5F0, 0x1F5F2, prExtendedPictographic}, // E0.0 [3] (🗰..🗲) MOOD BUBBLE..LIGHTNING MOOD - {0x1F5F3, 0x1F5F3, prExtendedPictographic}, // E0.7 [1] (🗳️) ballot box with ballot - {0x1F5F4, 0x1F5F9, prExtendedPictographic}, // E0.0 [6] (🗴..🗹) BALLOT SCRIPT X..BALLOT BOX WITH BOLD CHECK - {0x1F5FA, 0x1F5FA, prExtendedPictographic}, // E0.7 [1] (🗺️) world map - {0x1F5FB, 0x1F5FF, prExtendedPictographic}, // E0.6 [5] (🗻..🗿) mount fuji..moai - {0x1F600, 0x1F600, prExtendedPictographic}, // E1.0 [1] (😀) grinning face - {0x1F601, 0x1F606, prExtendedPictographic}, // E0.6 [6] (😁..😆) beaming face with smiling eyes..grinning squinting face - {0x1F607, 0x1F608, prExtendedPictographic}, // E1.0 [2] (😇..😈) smiling face with halo..smiling face with horns - {0x1F609, 0x1F60D, prExtendedPictographic}, // E0.6 [5] (😉..😍) winking face..smiling face with heart-eyes - {0x1F60E, 0x1F60E, prExtendedPictographic}, // E1.0 [1] (😎) smiling face with sunglasses - {0x1F60F, 0x1F60F, prExtendedPictographic}, // E0.6 [1] (😏) smirking face - {0x1F610, 0x1F610, prExtendedPictographic}, // E0.7 [1] (😐) neutral face - {0x1F611, 0x1F611, prExtendedPictographic}, // E1.0 [1] (😑) expressionless face - {0x1F612, 0x1F614, prExtendedPictographic}, // E0.6 [3] (😒..😔) unamused face..pensive face - {0x1F615, 0x1F615, prExtendedPictographic}, // E1.0 [1] (😕) confused face - {0x1F616, 0x1F616, prExtendedPictographic}, // E0.6 [1] (😖) confounded face - {0x1F617, 0x1F617, prExtendedPictographic}, // E1.0 [1] (😗) kissing face - {0x1F618, 0x1F618, prExtendedPictographic}, // E0.6 [1] (😘) face blowing a kiss - {0x1F619, 0x1F619, prExtendedPictographic}, // E1.0 [1] (😙) kissing face with smiling eyes - {0x1F61A, 0x1F61A, prExtendedPictographic}, // E0.6 [1] (😚) kissing face with closed eyes - {0x1F61B, 0x1F61B, prExtendedPictographic}, // E1.0 [1] (😛) face with tongue - {0x1F61C, 0x1F61E, prExtendedPictographic}, // E0.6 [3] (😜..😞) winking face with tongue..disappointed face - {0x1F61F, 0x1F61F, prExtendedPictographic}, // E1.0 [1] (😟) worried face - {0x1F620, 0x1F625, prExtendedPictographic}, // E0.6 [6] (😠..😥) angry face..sad but relieved face - {0x1F626, 0x1F627, prExtendedPictographic}, // E1.0 [2] (😦..😧) frowning face with open mouth..anguished face - {0x1F628, 0x1F62B, prExtendedPictographic}, // E0.6 [4] (😨..😫) fearful face..tired face - {0x1F62C, 0x1F62C, prExtendedPictographic}, // E1.0 [1] (😬) grimacing face - {0x1F62D, 0x1F62D, prExtendedPictographic}, // E0.6 [1] (😭) loudly crying face - {0x1F62E, 0x1F62F, prExtendedPictographic}, // E1.0 [2] (😮..😯) face with open mouth..hushed face - {0x1F630, 0x1F633, prExtendedPictographic}, // E0.6 [4] (😰..😳) anxious face with sweat..flushed face - {0x1F634, 0x1F634, prExtendedPictographic}, // E1.0 [1] (😴) sleeping face - {0x1F635, 0x1F635, prExtendedPictographic}, // E0.6 [1] (😵) face with crossed-out eyes - {0x1F636, 0x1F636, prExtendedPictographic}, // E1.0 [1] (😶) face without mouth - {0x1F637, 0x1F640, prExtendedPictographic}, // E0.6 [10] (😷..🙀) face with medical mask..weary cat - {0x1F641, 0x1F644, prExtendedPictographic}, // E1.0 [4] (🙁..🙄) slightly frowning face..face with rolling eyes - {0x1F645, 0x1F64F, prExtendedPictographic}, // E0.6 [11] (🙅..🙏) person gesturing NO..folded hands - {0x1F680, 0x1F680, prExtendedPictographic}, // E0.6 [1] (🚀) rocket - {0x1F681, 0x1F682, prExtendedPictographic}, // E1.0 [2] (🚁..🚂) helicopter..locomotive - {0x1F683, 0x1F685, prExtendedPictographic}, // E0.6 [3] (🚃..🚅) railway car..bullet train - {0x1F686, 0x1F686, prExtendedPictographic}, // E1.0 [1] (🚆) train - {0x1F687, 0x1F687, prExtendedPictographic}, // E0.6 [1] (🚇) metro - {0x1F688, 0x1F688, prExtendedPictographic}, // E1.0 [1] (🚈) light rail - {0x1F689, 0x1F689, prExtendedPictographic}, // E0.6 [1] (🚉) station - {0x1F68A, 0x1F68B, prExtendedPictographic}, // E1.0 [2] (🚊..🚋) tram..tram car - {0x1F68C, 0x1F68C, prExtendedPictographic}, // E0.6 [1] (🚌) bus - {0x1F68D, 0x1F68D, prExtendedPictographic}, // E0.7 [1] (🚍) oncoming bus - {0x1F68E, 0x1F68E, prExtendedPictographic}, // E1.0 [1] (🚎) trolleybus - {0x1F68F, 0x1F68F, prExtendedPictographic}, // E0.6 [1] (🚏) bus stop - {0x1F690, 0x1F690, prExtendedPictographic}, // E1.0 [1] (🚐) minibus - {0x1F691, 0x1F693, prExtendedPictographic}, // E0.6 [3] (🚑..🚓) ambulance..police car - {0x1F694, 0x1F694, prExtendedPictographic}, // E0.7 [1] (🚔) oncoming police car - {0x1F695, 0x1F695, prExtendedPictographic}, // E0.6 [1] (🚕) taxi - {0x1F696, 0x1F696, prExtendedPictographic}, // E1.0 [1] (🚖) oncoming taxi - {0x1F697, 0x1F697, prExtendedPictographic}, // E0.6 [1] (🚗) automobile - {0x1F698, 0x1F698, prExtendedPictographic}, // E0.7 [1] (🚘) oncoming automobile - {0x1F699, 0x1F69A, prExtendedPictographic}, // E0.6 [2] (🚙..🚚) sport utility vehicle..delivery truck - {0x1F69B, 0x1F6A1, prExtendedPictographic}, // E1.0 [7] (🚛..🚡) articulated lorry..aerial tramway - {0x1F6A2, 0x1F6A2, prExtendedPictographic}, // E0.6 [1] (🚢) ship - {0x1F6A3, 0x1F6A3, prExtendedPictographic}, // E1.0 [1] (🚣) person rowing boat - {0x1F6A4, 0x1F6A5, prExtendedPictographic}, // E0.6 [2] (🚤..🚥) speedboat..horizontal traffic light - {0x1F6A6, 0x1F6A6, prExtendedPictographic}, // E1.0 [1] (🚦) vertical traffic light - {0x1F6A7, 0x1F6AD, prExtendedPictographic}, // E0.6 [7] (🚧..🚭) construction..no smoking - {0x1F6AE, 0x1F6B1, prExtendedPictographic}, // E1.0 [4] (🚮..🚱) litter in bin sign..non-potable water - {0x1F6B2, 0x1F6B2, prExtendedPictographic}, // E0.6 [1] (🚲) bicycle - {0x1F6B3, 0x1F6B5, prExtendedPictographic}, // E1.0 [3] (🚳..🚵) no bicycles..person mountain biking - {0x1F6B6, 0x1F6B6, prExtendedPictographic}, // E0.6 [1] (🚶) person walking - {0x1F6B7, 0x1F6B8, prExtendedPictographic}, // E1.0 [2] (🚷..🚸) no pedestrians..children crossing - {0x1F6B9, 0x1F6BE, prExtendedPictographic}, // E0.6 [6] (🚹..🚾) men’s room..water closet - {0x1F6BF, 0x1F6BF, prExtendedPictographic}, // E1.0 [1] (🚿) shower - {0x1F6C0, 0x1F6C0, prExtendedPictographic}, // E0.6 [1] (🛀) person taking bath - {0x1F6C1, 0x1F6C5, prExtendedPictographic}, // E1.0 [5] (🛁..🛅) bathtub..left luggage - {0x1F6C6, 0x1F6CA, prExtendedPictographic}, // E0.0 [5] (🛆..🛊) TRIANGLE WITH ROUNDED CORNERS..GIRLS SYMBOL - {0x1F6CB, 0x1F6CB, prExtendedPictographic}, // E0.7 [1] (🛋️) couch and lamp - {0x1F6CC, 0x1F6CC, prExtendedPictographic}, // E1.0 [1] (🛌) person in bed - {0x1F6CD, 0x1F6CF, prExtendedPictographic}, // E0.7 [3] (🛍️..🛏️) shopping bags..bed - {0x1F6D0, 0x1F6D0, prExtendedPictographic}, // E1.0 [1] (🛐) place of worship - {0x1F6D1, 0x1F6D2, prExtendedPictographic}, // E3.0 [2] (🛑..🛒) stop sign..shopping cart - {0x1F6D3, 0x1F6D4, prExtendedPictographic}, // E0.0 [2] (🛓..🛔) STUPA..PAGODA - {0x1F6D5, 0x1F6D5, prExtendedPictographic}, // E12.0 [1] (🛕) hindu temple - {0x1F6D6, 0x1F6D7, prExtendedPictographic}, // E13.0 [2] (🛖..🛗) hut..elevator - {0x1F6D8, 0x1F6DB, prExtendedPictographic}, // E0.0 [4] (🛘..🛛) .. - {0x1F6DC, 0x1F6DC, prExtendedPictographic}, // E15.0 [1] (🛜) wireless - {0x1F6DD, 0x1F6DF, prExtendedPictographic}, // E14.0 [3] (🛝..🛟) playground slide..ring buoy - {0x1F6E0, 0x1F6E5, prExtendedPictographic}, // E0.7 [6] (🛠️..🛥️) hammer and wrench..motor boat - {0x1F6E6, 0x1F6E8, prExtendedPictographic}, // E0.0 [3] (🛦..🛨) UP-POINTING MILITARY AIRPLANE..UP-POINTING SMALL AIRPLANE - {0x1F6E9, 0x1F6E9, prExtendedPictographic}, // E0.7 [1] (🛩️) small airplane - {0x1F6EA, 0x1F6EA, prExtendedPictographic}, // E0.0 [1] (🛪) NORTHEAST-POINTING AIRPLANE - {0x1F6EB, 0x1F6EC, prExtendedPictographic}, // E1.0 [2] (🛫..🛬) airplane departure..airplane arrival - {0x1F6ED, 0x1F6EF, prExtendedPictographic}, // E0.0 [3] (🛭..🛯) .. - {0x1F6F0, 0x1F6F0, prExtendedPictographic}, // E0.7 [1] (🛰️) satellite - {0x1F6F1, 0x1F6F2, prExtendedPictographic}, // E0.0 [2] (🛱..🛲) ONCOMING FIRE ENGINE..DIESEL LOCOMOTIVE - {0x1F6F3, 0x1F6F3, prExtendedPictographic}, // E0.7 [1] (🛳️) passenger ship - {0x1F6F4, 0x1F6F6, prExtendedPictographic}, // E3.0 [3] (🛴..🛶) kick scooter..canoe - {0x1F6F7, 0x1F6F8, prExtendedPictographic}, // E5.0 [2] (🛷..🛸) sled..flying saucer - {0x1F6F9, 0x1F6F9, prExtendedPictographic}, // E11.0 [1] (🛹) skateboard - {0x1F6FA, 0x1F6FA, prExtendedPictographic}, // E12.0 [1] (🛺) auto rickshaw - {0x1F6FB, 0x1F6FC, prExtendedPictographic}, // E13.0 [2] (🛻..🛼) pickup truck..roller skate - {0x1F6FD, 0x1F6FF, prExtendedPictographic}, // E0.0 [3] (🛽..🛿) .. - {0x1F774, 0x1F77F, prExtendedPictographic}, // E0.0 [12] (🝴..🝿) LOT OF FORTUNE..ORCUS - {0x1F7D5, 0x1F7DF, prExtendedPictographic}, // E0.0 [11] (🟕..🟟) CIRCLED TRIANGLE.. - {0x1F7E0, 0x1F7EB, prExtendedPictographic}, // E12.0 [12] (🟠..🟫) orange circle..brown square - {0x1F7EC, 0x1F7EF, prExtendedPictographic}, // E0.0 [4] (🟬..🟯) .. - {0x1F7F0, 0x1F7F0, prExtendedPictographic}, // E14.0 [1] (🟰) heavy equals sign - {0x1F7F1, 0x1F7FF, prExtendedPictographic}, // E0.0 [15] (🟱..🟿) .. - {0x1F80C, 0x1F80F, prExtendedPictographic}, // E0.0 [4] (🠌..🠏) .. - {0x1F848, 0x1F84F, prExtendedPictographic}, // E0.0 [8] (🡈..🡏) .. - {0x1F85A, 0x1F85F, prExtendedPictographic}, // E0.0 [6] (🡚..🡟) .. - {0x1F888, 0x1F88F, prExtendedPictographic}, // E0.0 [8] (🢈..🢏) .. - {0x1F8AE, 0x1F8FF, prExtendedPictographic}, // E0.0 [82] (🢮..🣿) .. - {0x1F90C, 0x1F90C, prExtendedPictographic}, // E13.0 [1] (🤌) pinched fingers - {0x1F90D, 0x1F90F, prExtendedPictographic}, // E12.0 [3] (🤍..🤏) white heart..pinching hand - {0x1F910, 0x1F918, prExtendedPictographic}, // E1.0 [9] (🤐..🤘) zipper-mouth face..sign of the horns - {0x1F919, 0x1F91E, prExtendedPictographic}, // E3.0 [6] (🤙..🤞) call me hand..crossed fingers - {0x1F91F, 0x1F91F, prExtendedPictographic}, // E5.0 [1] (🤟) love-you gesture - {0x1F920, 0x1F927, prExtendedPictographic}, // E3.0 [8] (🤠..🤧) cowboy hat face..sneezing face - {0x1F928, 0x1F92F, prExtendedPictographic}, // E5.0 [8] (🤨..🤯) face with raised eyebrow..exploding head - {0x1F930, 0x1F930, prExtendedPictographic}, // E3.0 [1] (🤰) pregnant woman - {0x1F931, 0x1F932, prExtendedPictographic}, // E5.0 [2] (🤱..🤲) breast-feeding..palms up together - {0x1F933, 0x1F93A, prExtendedPictographic}, // E3.0 [8] (🤳..🤺) selfie..person fencing - {0x1F93C, 0x1F93E, prExtendedPictographic}, // E3.0 [3] (🤼..🤾) people wrestling..person playing handball - {0x1F93F, 0x1F93F, prExtendedPictographic}, // E12.0 [1] (🤿) diving mask - {0x1F940, 0x1F945, prExtendedPictographic}, // E3.0 [6] (🥀..🥅) wilted flower..goal net - {0x1F947, 0x1F94B, prExtendedPictographic}, // E3.0 [5] (🥇..🥋) 1st place medal..martial arts uniform - {0x1F94C, 0x1F94C, prExtendedPictographic}, // E5.0 [1] (🥌) curling stone - {0x1F94D, 0x1F94F, prExtendedPictographic}, // E11.0 [3] (🥍..🥏) lacrosse..flying disc - {0x1F950, 0x1F95E, prExtendedPictographic}, // E3.0 [15] (🥐..🥞) croissant..pancakes - {0x1F95F, 0x1F96B, prExtendedPictographic}, // E5.0 [13] (🥟..🥫) dumpling..canned food - {0x1F96C, 0x1F970, prExtendedPictographic}, // E11.0 [5] (🥬..🥰) leafy green..smiling face with hearts - {0x1F971, 0x1F971, prExtendedPictographic}, // E12.0 [1] (🥱) yawning face - {0x1F972, 0x1F972, prExtendedPictographic}, // E13.0 [1] (🥲) smiling face with tear - {0x1F973, 0x1F976, prExtendedPictographic}, // E11.0 [4] (🥳..🥶) partying face..cold face - {0x1F977, 0x1F978, prExtendedPictographic}, // E13.0 [2] (🥷..🥸) ninja..disguised face - {0x1F979, 0x1F979, prExtendedPictographic}, // E14.0 [1] (🥹) face holding back tears - {0x1F97A, 0x1F97A, prExtendedPictographic}, // E11.0 [1] (🥺) pleading face - {0x1F97B, 0x1F97B, prExtendedPictographic}, // E12.0 [1] (🥻) sari - {0x1F97C, 0x1F97F, prExtendedPictographic}, // E11.0 [4] (🥼..🥿) lab coat..flat shoe - {0x1F980, 0x1F984, prExtendedPictographic}, // E1.0 [5] (🦀..🦄) crab..unicorn - {0x1F985, 0x1F991, prExtendedPictographic}, // E3.0 [13] (🦅..🦑) eagle..squid - {0x1F992, 0x1F997, prExtendedPictographic}, // E5.0 [6] (🦒..🦗) giraffe..cricket - {0x1F998, 0x1F9A2, prExtendedPictographic}, // E11.0 [11] (🦘..🦢) kangaroo..swan - {0x1F9A3, 0x1F9A4, prExtendedPictographic}, // E13.0 [2] (🦣..🦤) mammoth..dodo - {0x1F9A5, 0x1F9AA, prExtendedPictographic}, // E12.0 [6] (🦥..🦪) sloth..oyster - {0x1F9AB, 0x1F9AD, prExtendedPictographic}, // E13.0 [3] (🦫..🦭) beaver..seal - {0x1F9AE, 0x1F9AF, prExtendedPictographic}, // E12.0 [2] (🦮..🦯) guide dog..white cane - {0x1F9B0, 0x1F9B9, prExtendedPictographic}, // E11.0 [10] (🦰..🦹) red hair..supervillain - {0x1F9BA, 0x1F9BF, prExtendedPictographic}, // E12.0 [6] (🦺..🦿) safety vest..mechanical leg - {0x1F9C0, 0x1F9C0, prExtendedPictographic}, // E1.0 [1] (🧀) cheese wedge - {0x1F9C1, 0x1F9C2, prExtendedPictographic}, // E11.0 [2] (🧁..🧂) cupcake..salt - {0x1F9C3, 0x1F9CA, prExtendedPictographic}, // E12.0 [8] (🧃..🧊) beverage box..ice - {0x1F9CB, 0x1F9CB, prExtendedPictographic}, // E13.0 [1] (🧋) bubble tea - {0x1F9CC, 0x1F9CC, prExtendedPictographic}, // E14.0 [1] (🧌) troll - {0x1F9CD, 0x1F9CF, prExtendedPictographic}, // E12.0 [3] (🧍..🧏) person standing..deaf person - {0x1F9D0, 0x1F9E6, prExtendedPictographic}, // E5.0 [23] (🧐..🧦) face with monocle..socks - {0x1F9E7, 0x1F9FF, prExtendedPictographic}, // E11.0 [25] (🧧..🧿) red envelope..nazar amulet - {0x1FA00, 0x1FA6F, prExtendedPictographic}, // E0.0 [112] (🨀..🩯) NEUTRAL CHESS KING.. - {0x1FA70, 0x1FA73, prExtendedPictographic}, // E12.0 [4] (🩰..🩳) ballet shoes..shorts - {0x1FA74, 0x1FA74, prExtendedPictographic}, // E13.0 [1] (🩴) thong sandal - {0x1FA75, 0x1FA77, prExtendedPictographic}, // E15.0 [3] (🩵..🩷) light blue heart..pink heart - {0x1FA78, 0x1FA7A, prExtendedPictographic}, // E12.0 [3] (🩸..🩺) drop of blood..stethoscope - {0x1FA7B, 0x1FA7C, prExtendedPictographic}, // E14.0 [2] (🩻..🩼) x-ray..crutch - {0x1FA7D, 0x1FA7F, prExtendedPictographic}, // E0.0 [3] (🩽..🩿) .. - {0x1FA80, 0x1FA82, prExtendedPictographic}, // E12.0 [3] (🪀..🪂) yo-yo..parachute - {0x1FA83, 0x1FA86, prExtendedPictographic}, // E13.0 [4] (🪃..🪆) boomerang..nesting dolls - {0x1FA87, 0x1FA88, prExtendedPictographic}, // E15.0 [2] (🪇..🪈) maracas..flute - {0x1FA89, 0x1FA8F, prExtendedPictographic}, // E0.0 [7] (🪉..🪏) .. - {0x1FA90, 0x1FA95, prExtendedPictographic}, // E12.0 [6] (🪐..🪕) ringed planet..banjo - {0x1FA96, 0x1FAA8, prExtendedPictographic}, // E13.0 [19] (🪖..🪨) military helmet..rock - {0x1FAA9, 0x1FAAC, prExtendedPictographic}, // E14.0 [4] (🪩..🪬) mirror ball..hamsa - {0x1FAAD, 0x1FAAF, prExtendedPictographic}, // E15.0 [3] (🪭..🪯) folding hand fan..khanda - {0x1FAB0, 0x1FAB6, prExtendedPictographic}, // E13.0 [7] (🪰..🪶) fly..feather - {0x1FAB7, 0x1FABA, prExtendedPictographic}, // E14.0 [4] (🪷..🪺) lotus..nest with eggs - {0x1FABB, 0x1FABD, prExtendedPictographic}, // E15.0 [3] (🪻..🪽) hyacinth..wing - {0x1FABE, 0x1FABE, prExtendedPictographic}, // E0.0 [1] (🪾) - {0x1FABF, 0x1FABF, prExtendedPictographic}, // E15.0 [1] (🪿) goose - {0x1FAC0, 0x1FAC2, prExtendedPictographic}, // E13.0 [3] (🫀..🫂) anatomical heart..people hugging - {0x1FAC3, 0x1FAC5, prExtendedPictographic}, // E14.0 [3] (🫃..🫅) pregnant man..person with crown - {0x1FAC6, 0x1FACD, prExtendedPictographic}, // E0.0 [8] (🫆..🫍) .. - {0x1FACE, 0x1FACF, prExtendedPictographic}, // E15.0 [2] (🫎..🫏) moose..donkey - {0x1FAD0, 0x1FAD6, prExtendedPictographic}, // E13.0 [7] (🫐..🫖) blueberries..teapot - {0x1FAD7, 0x1FAD9, prExtendedPictographic}, // E14.0 [3] (🫗..🫙) pouring liquid..jar - {0x1FADA, 0x1FADB, prExtendedPictographic}, // E15.0 [2] (🫚..🫛) ginger root..pea pod - {0x1FADC, 0x1FADF, prExtendedPictographic}, // E0.0 [4] (🫜..🫟) .. - {0x1FAE0, 0x1FAE7, prExtendedPictographic}, // E14.0 [8] (🫠..🫧) melting face..bubbles - {0x1FAE8, 0x1FAE8, prExtendedPictographic}, // E15.0 [1] (🫨) shaking face - {0x1FAE9, 0x1FAEF, prExtendedPictographic}, // E0.0 [7] (🫩..🫯) .. - {0x1FAF0, 0x1FAF6, prExtendedPictographic}, // E14.0 [7] (🫰..🫶) hand with index finger and thumb crossed..heart hands - {0x1FAF7, 0x1FAF8, prExtendedPictographic}, // E15.0 [2] (🫷..🫸) leftwards pushing hand..rightwards pushing hand - {0x1FAF9, 0x1FAFF, prExtendedPictographic}, // E0.0 [7] (🫹..🫿) .. - {0x1FBF0, 0x1FBF9, prNumeric}, // Nd [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE - {0x1FC00, 0x1FFFD, prExtendedPictographic}, // E0.0[1022] (🰀..🿽) .. - {0xE0001, 0xE0001, prFormat}, // Cf LANGUAGE TAG - {0xE0020, 0xE007F, prExtend}, // Cf [96] TAG SPACE..CANCEL TAG - {0xE0100, 0xE01EF, prExtend}, // Mn [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256 -} diff --git a/vendor/github.com/rivo/uniseg/wordrules.go b/vendor/github.com/rivo/uniseg/wordrules.go deleted file mode 100644 index 57a8c68..0000000 --- a/vendor/github.com/rivo/uniseg/wordrules.go +++ /dev/null @@ -1,282 +0,0 @@ -package uniseg - -import "unicode/utf8" - -// The states of the word break parser. -const ( - wbAny = iota - wbCR - wbLF - wbNewline - wbWSegSpace - wbHebrewLetter - wbALetter - wbWB7 - wbWB7c - wbNumeric - wbWB11 - wbKatakana - wbExtendNumLet - wbOddRI - wbEvenRI - wbZWJBit = 16 // This bit is set for any states followed by at least one zero-width joiner (see WB4 and WB3c). -) - -// wbTransitions implements the word break parser's state transitions. It's -// anologous to [grTransitions], see comments there for details. -// -// Unicode version 15.0.0. -func wbTransitions(state, prop int) (newState int, wordBreak bool, rule int) { - switch uint64(state) | uint64(prop)<<32 { - // WB3b. - case wbAny | prNewline<<32: - return wbNewline, true, 32 - case wbAny | prCR<<32: - return wbCR, true, 32 - case wbAny | prLF<<32: - return wbLF, true, 32 - - // WB3a. - case wbNewline | prAny<<32: - return wbAny, true, 31 - case wbCR | prAny<<32: - return wbAny, true, 31 - case wbLF | prAny<<32: - return wbAny, true, 31 - - // WB3. - case wbCR | prLF<<32: - return wbLF, false, 30 - - // WB3d. - case wbAny | prWSegSpace<<32: - return wbWSegSpace, true, 9990 - case wbWSegSpace | prWSegSpace<<32: - return wbWSegSpace, false, 34 - - // WB5. - case wbAny | prALetter<<32: - return wbALetter, true, 9990 - case wbAny | prHebrewLetter<<32: - return wbHebrewLetter, true, 9990 - case wbALetter | prALetter<<32: - return wbALetter, false, 50 - case wbALetter | prHebrewLetter<<32: - return wbHebrewLetter, false, 50 - case wbHebrewLetter | prALetter<<32: - return wbALetter, false, 50 - case wbHebrewLetter | prHebrewLetter<<32: - return wbHebrewLetter, false, 50 - - // WB7. Transitions to wbWB7 handled by transitionWordBreakState(). - case wbWB7 | prALetter<<32: - return wbALetter, false, 70 - case wbWB7 | prHebrewLetter<<32: - return wbHebrewLetter, false, 70 - - // WB7a. - case wbHebrewLetter | prSingleQuote<<32: - return wbAny, false, 71 - - // WB7c. Transitions to wbWB7c handled by transitionWordBreakState(). - case wbWB7c | prHebrewLetter<<32: - return wbHebrewLetter, false, 73 - - // WB8. - case wbAny | prNumeric<<32: - return wbNumeric, true, 9990 - case wbNumeric | prNumeric<<32: - return wbNumeric, false, 80 - - // WB9. - case wbALetter | prNumeric<<32: - return wbNumeric, false, 90 - case wbHebrewLetter | prNumeric<<32: - return wbNumeric, false, 90 - - // WB10. - case wbNumeric | prALetter<<32: - return wbALetter, false, 100 - case wbNumeric | prHebrewLetter<<32: - return wbHebrewLetter, false, 100 - - // WB11. Transitions to wbWB11 handled by transitionWordBreakState(). - case wbWB11 | prNumeric<<32: - return wbNumeric, false, 110 - - // WB13. - case wbAny | prKatakana<<32: - return wbKatakana, true, 9990 - case wbKatakana | prKatakana<<32: - return wbKatakana, false, 130 - - // WB13a. - case wbAny | prExtendNumLet<<32: - return wbExtendNumLet, true, 9990 - case wbALetter | prExtendNumLet<<32: - return wbExtendNumLet, false, 131 - case wbHebrewLetter | prExtendNumLet<<32: - return wbExtendNumLet, false, 131 - case wbNumeric | prExtendNumLet<<32: - return wbExtendNumLet, false, 131 - case wbKatakana | prExtendNumLet<<32: - return wbExtendNumLet, false, 131 - case wbExtendNumLet | prExtendNumLet<<32: - return wbExtendNumLet, false, 131 - - // WB13b. - case wbExtendNumLet | prALetter<<32: - return wbALetter, false, 132 - case wbExtendNumLet | prHebrewLetter<<32: - return wbHebrewLetter, false, 132 - case wbExtendNumLet | prNumeric<<32: - return wbNumeric, false, 132 - case wbExtendNumLet | prKatakana<<32: - return wbKatakana, false, 132 - - default: - return -1, false, -1 - } -} - -// transitionWordBreakState determines the new state of the word break parser -// given the current state and the next code point. It also returns whether a -// word boundary was detected. If more than one code point is needed to -// determine the new state, the byte slice or the string starting after rune "r" -// can be used (whichever is not nil or empty) for further lookups. -func transitionWordBreakState(state int, r rune, b []byte, str string) (newState int, wordBreak bool) { - // Determine the property of the next character. - nextProperty := property(workBreakCodePoints, r) - - // "Replacing Ignore Rules". - if nextProperty == prZWJ { - // WB4 (for zero-width joiners). - if state == wbNewline || state == wbCR || state == wbLF { - return wbAny | wbZWJBit, true // Make sure we don't apply WB4 to WB3a. - } - if state < 0 { - return wbAny | wbZWJBit, false - } - return state | wbZWJBit, false - } else if nextProperty == prExtend || nextProperty == prFormat { - // WB4 (for Extend and Format). - if state == wbNewline || state == wbCR || state == wbLF { - return wbAny, true // Make sure we don't apply WB4 to WB3a. - } - if state == wbWSegSpace || state == wbAny|wbZWJBit { - return wbAny, false // We don't break but this is also not WB3d or WB3c. - } - if state < 0 { - return wbAny, false - } - return state, false - } else if nextProperty == prExtendedPictographic && state >= 0 && state&wbZWJBit != 0 { - // WB3c. - return wbAny, false - } - if state >= 0 { - state = state &^ wbZWJBit - } - - // Find the applicable transition in the table. - var rule int - newState, wordBreak, rule = wbTransitions(state, nextProperty) - if newState < 0 { - // No specific transition found. Try the less specific ones. - anyPropState, anyPropWordBreak, anyPropRule := wbTransitions(state, prAny) - anyStateState, anyStateWordBreak, anyStateRule := wbTransitions(wbAny, nextProperty) - if anyPropState >= 0 && anyStateState >= 0 { - // Both apply. We'll use a mix (see comments for grTransitions). - newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule - if anyPropRule < anyStateRule { - wordBreak, rule = anyPropWordBreak, anyPropRule - } - } else if anyPropState >= 0 { - // We only have a specific state. - newState, wordBreak, rule = anyPropState, anyPropWordBreak, anyPropRule - // This branch will probably never be reached because okAnyState will - // always be true given the current transition map. But we keep it here - // for future modifications to the transition map where this may not be - // true anymore. - } else if anyStateState >= 0 { - // We only have a specific property. - newState, wordBreak, rule = anyStateState, anyStateWordBreak, anyStateRule - } else { - // No known transition. WB999: Any ÷ Any. - newState, wordBreak, rule = wbAny, true, 9990 - } - } - - // For those rules that need to look up runes further in the string, we - // determine the property after nextProperty, skipping over Format, Extend, - // and ZWJ (according to WB4). It's -1 if not needed, if such a rune cannot - // be determined (because the text ends or the rune is faulty). - farProperty := -1 - if rule > 60 && - (state == wbALetter || state == wbHebrewLetter || state == wbNumeric) && - (nextProperty == prMidLetter || nextProperty == prMidNumLet || nextProperty == prSingleQuote || // WB6. - nextProperty == prDoubleQuote || // WB7b. - nextProperty == prMidNum) { // WB12. - for { - var ( - r rune - length int - ) - if b != nil { // Byte slice version. - r, length = utf8.DecodeRune(b) - b = b[length:] - } else { // String version. - r, length = utf8.DecodeRuneInString(str) - str = str[length:] - } - if r == utf8.RuneError { - break - } - prop := property(workBreakCodePoints, r) - if prop == prExtend || prop == prFormat || prop == prZWJ { - continue - } - farProperty = prop - break - } - } - - // WB6. - if rule > 60 && - (state == wbALetter || state == wbHebrewLetter) && - (nextProperty == prMidLetter || nextProperty == prMidNumLet || nextProperty == prSingleQuote) && - (farProperty == prALetter || farProperty == prHebrewLetter) { - return wbWB7, false - } - - // WB7b. - if rule > 72 && - state == wbHebrewLetter && - nextProperty == prDoubleQuote && - farProperty == prHebrewLetter { - return wbWB7c, false - } - - // WB12. - if rule > 120 && - state == wbNumeric && - (nextProperty == prMidNum || nextProperty == prMidNumLet || nextProperty == prSingleQuote) && - farProperty == prNumeric { - return wbWB11, false - } - - // WB15 and WB16. - if newState == wbAny && nextProperty == prRegionalIndicator { - if state != wbOddRI && state != wbEvenRI { // Includes state == -1. - // Transition into the first RI. - return wbOddRI, true - } - if state == wbOddRI { - // Don't break pairs of Regional Indicators. - return wbEvenRI, false - } - return wbOddRI, true // We can break after a pair. - } - - return -} diff --git a/vendor/go.mau.fi/util/confusable/confusables.go b/vendor/go.mau.fi/util/confusable/confusables.go index b016f3c..7ebe66c 100644 --- a/vendor/go.mau.fi/util/confusable/confusables.go +++ b/vendor/go.mau.fi/util/confusable/confusables.go @@ -54,6 +54,8 @@ func GetReplacement(input rune) string { return "ة" case 248: return "o̸" + case 254: + return "p" case 272: return "D̵" case 273: @@ -84,6 +86,8 @@ func GetReplacement(input rune) string { return "ɲ" case 329: return "'n" + case 331: + return "n̩" case 336: return "Ö" case 338: @@ -121,7 +125,7 @@ func GetReplacement(input rune) string { case 401: return "F̦" case 402: - return "f̦" + return "f" case 403: return "G'" case 406: @@ -177,7 +181,7 @@ func GetReplacement(input rune) string { case 445: return "s" case 447: - return "þ" + return "p" case 448: return "l" case 449: @@ -336,6 +340,8 @@ func GetReplacement(input rune) string { return "ȝ" case 660: return "?" + case 661: + return "\ua7ce" case 672: return "q̔" case 675: @@ -351,7 +357,7 @@ func GetReplacement(input rune) string { case 680: return "tɕ" case 681: - return "fŋ" + return "fn̩" case 682: return "ls" case 683: @@ -434,6 +440,8 @@ func GetReplacement(input rune) string { return "̓" case 791: return "ِ" + case 794: + return "\u1ae9" case 800: return "̱" case 801: @@ -460,6 +468,8 @@ func GetReplacement(input rune) string { return "̨" case 839: return "̳" + case 840: + return "\U00010efa" case 855: return "͐" case 856: @@ -572,10 +582,18 @@ func GetReplacement(input rune) string { return "ς" case 988: return "F" + case 996: + return "Ч" + case 997: + return "ч" case 1000: return "2" case 1001: return "ƨ" + case 1004: + return "6" + case 1005: + return "o" case 1008: return "ĸ" case 1009: @@ -591,7 +609,7 @@ func GetReplacement(input rune) string { case 1015: return "Þ" case 1016: - return "þ" + return "p" case 1017: return "C" case 1018: @@ -688,6 +706,8 @@ func GetReplacement(input rune) string { return "ɸ" case 1093: return "x" + case 1096: + return "w" case 1098: return "ˉb" case 1099: @@ -708,6 +728,8 @@ func GetReplacement(input rune) string { return "h̵" case 1117: return "й" + case 1119: + return "u̩" case 1121: return "w" case 1122: @@ -815,7 +837,7 @@ func GetReplacement(input rune) string { case 1230: return "ʍ̦" case 1231: - return "i" + return "l" case 1236: return "AE" case 1237: @@ -880,6 +902,8 @@ func GetReplacement(input rune) string { return "ẟ" case 1392: return "h" + case 1394: + return "n̩" case 1397: return "ȷ" case 1400: @@ -892,12 +916,14 @@ func GetReplacement(input rune) string { return "u" case 1409: return "g" + case 1410: + return "i" case 1412: return "f" case 1413: return "o" case 1415: - return "եւ" + return "եi" case 1417: return ":" case 1436: @@ -1052,6 +1078,8 @@ func GetReplacement(input rune) string { return "ىٴ" case 1657: return "ىؕ" + case 1658: + return "ت" case 1662: return "ىۛ" case 1665: @@ -1064,6 +1092,8 @@ func GetReplacement(input rune) string { return "ڊؕ" case 1678: return "دۛ" + case 1679: + return "دۛ" case 1681: return "رؕ" case 1682: @@ -1161,9 +1191,9 @@ func GetReplacement(input rune) string { case 1785: return "٩" case 1789: - return "ء͈" + return "ء\U00010efa" case 1790: - return "م͈" + return "م\U00010efa" case 1791: return "ô" case 1793: @@ -1184,6 +1214,8 @@ func GetReplacement(input rune) string { return "́" case 1873: return "بۛ" + case 1874: + return "ىۛ" case 1878: return "ى̆" case 1890: @@ -1222,6 +1254,8 @@ func GetReplacement(input rune) string { return "'" case 2042: return "_" + case 2191: + return "ى̊" case 2209: return "بٔ" case 2212: @@ -1256,6 +1290,16 @@ func GetReplacement(input rune) string { return "ڡ" case 2237: return "ى" + case 2238: + return "ىۛ̆" + case 2239: + return "ت̆" + case 2240: + return "ىؕ̆" + case 2241: + return "چ̆" + case 2242: + return "ك̆" case 2277: return "ٌ" case 2280: @@ -1299,33 +1343,57 @@ func GetReplacement(input rune) string { case 2312: return "र्इ" case 2317: - return "एॅ" + return "ए̆" case 2318: return "एॆ" case 2320: - return "एे" + return "ए\U00011b64" case 2321: - return "अॉ" + return "अा̆" case 2322: return "अाॆ" case 2323: - return "अाे" + return "अा\U00011b64" case 2324: return "अाै" + case 2363: + return "ाऺ" case 2364: return "̣" + case 2367: + return "ি" + case 2373: + return "̆" + case 2375: + return "\U00011b64" + case 2377: + return "ा̆" case 2386: return "̱" case 2387: return "̀" case 2388: return "́" + case 2390: + return "\U00011b62" + case 2391: + return "\U00011b63" case 2405: return "।।" case 2406: return "o" case 2407: return "٩" + case 2409: + return "3" + case 2418: + return "अ̆" + case 2419: + return "अऺ" + case 2420: + return "अाऺ" + case 2421: + return "अॏ" case 2429: return "?" case 2433: @@ -1339,11 +1407,13 @@ func GetReplacement(input rune) string { case 2529: return "ঋৃ" case 2534: - return "O" + return "o" case 2538: return "8" case 2541: return "9" + case 2544: + return "র" case 2562: return "̇" case 2563: @@ -1351,21 +1421,51 @@ func GetReplacement(input rune) string { case 2566: return "ਅਾ" case 2567: - return "ੲਿ" + return "प्टি" case 2568: - return "ੲੀ" + return "प्टੀ" case 2569: - return "ੳੁ" + return "ੳ\U00011b62" case 2570: - return "ੳੂ" + return "ੳ\U00011b63" case 2575: - return "ੲੇ" + return "प्ट\U00011b64" case 2576: - return "ਅੈ" + return "ਅै" case 2580: return "ਅੌ" + case 2581: + return "व" + case 2588: + return "त्त" + case 2591: + return "ट" + case 2592: + return "ठ" + case 2596: + return "उ" + case 2599: + return "प" + case 2603: + return "ढ" + case 2606: + return "भ" + case 2613: + return "ह" + case 2616: + return "म" case 2620: return "̣" + case 2623: + return "ি" + case 2625: + return "\U00011b62" + case 2626: + return "\U00011b63" + case 2631: + return "\U00011b64" + case 2632: + return "ै" case 2635: return "ॆ" case 2637: @@ -1376,6 +1476,8 @@ func GetReplacement(input rune) string { return "9" case 2666: return "8" + case 2674: + return "प्ट" case 2689: return "̆̇" case 2690: @@ -1396,6 +1498,10 @@ func GetReplacement(input rune) string { return "અાે" case 2708: return "અાૈ" + case 2730: + return "ч" + case 2736: + return "२" case 2748: return "̣" case 2749: @@ -1411,9 +1517,11 @@ func GetReplacement(input rune) string { case 2792: return "२" case 2793: - return "३" + return "3" case 2794: return "४" + case 2795: + return "ч" case 2798: return "८" case 2800: @@ -1429,17 +1537,21 @@ func GetReplacement(input rune) string { case 2876: return "̣" case 2918: - return "O" + return "o" case 2920: return "9" case 2946: return "̊" case 2954: return "உள" + case 2964: + return "ஒள" case 2972: return "ஐ" case 2992: return "ஈ" + case 3000: + return "ஶ" case 3006: return "ஈ" case 3016: @@ -1494,6 +1606,8 @@ func GetReplacement(input rune) string { return "ఒౕ" case 3092: return "ఒౌ" + case 3094: + return "ಖ̣" case 3104: return "రּ" case 3106: @@ -1530,28 +1644,52 @@ func GetReplacement(input rune) string { return "ఆ" case 3207: return "ఇ" + case 3216: + return "ఐ" case 3218: return "ఒ" case 3219: return "ఒౕ" case 3220: return "ఒౌ" + case 3223: + return "గ" case 3228: return "జ" + case 3229: + return "ఝ" case 3230: return "ఞ" + case 3231: + return "ట" case 3235: return "ణ" + case 3238: + return "ద" + case 3240: + return "న" case 3247: return "య" + case 3248: + return "ర" case 3249: return "ఱ" case 3250: return "ల" + case 3251: + return "ళ" + case 3263: + return "ి" + case 3265: + return "ు" + case 3267: + return "ృ" + case 3292: + return "\u0c5c" case 3297: return "ಌಾ" case 3302: - return "o" + return "O" case 3303: return "౧" case 3304: @@ -1573,19 +1711,25 @@ func GetReplacement(input rune) string { case 3340: return "നു" case 3344: - return "എെ" + return "ெഎ" case 3347: return "ഒാ" case 3348: return "ഒൗ" + case 3350: + return "வ" case 3353: return "നു" case 3356: return "ஐ" + case 3359: + return "s" case 3360: return "o" case 3363: return "ண" + case 3365: + return "ம" case 3377: return "ര" case 3380: @@ -1602,8 +1746,12 @@ func GetReplacement(input rune) string { return "ു" case 3395: return "ു" + case 3398: + return "ெ" + case 3399: + return "ே" case 3400: - return "െെ" + return "ெெ" case 3406: return "ॱ" case 3418: @@ -1630,14 +1778,36 @@ func GetReplacement(input rune) string { return "ഹ്മ" case 3449: return "നു" + case 3450: + return "ண്" case 3451: return "ന്" case 3452: return "ര്" + case 3453: + return "ല്" + case 3454: + return "ള്" case 3458: return "o" case 3459: return "ঃ" + case 3469: + return "සෘ" + case 3474: + return "එ්" + case 3475: + return "එෙ" + case 3509: + return "එ" + case 3510: + return "ඛ" + case 3513: + return "ඔ" + case 3520: + return "ච" + case 3524: + return "භ" case 3561: return "෨ා" case 3562: @@ -1732,6 +1902,10 @@ func GetReplacement(input rune) string { return "ྲཱྀ" case 3961: return "ླཱྀ" + case 3963: + return "ེེ" + case 3965: + return "ོོ" case 4046: return "༝༚" case 4053: @@ -1739,17 +1913,25 @@ func GetReplacement(input rune) string { case 4054: return "卍" case 4096: - return "ဂာ" + return "രာ" + case 4098: + return "ര" + case 4100: + return "c" case 4112: return "oာ" case 4125: return "o" case 4127: return "ပာ" + case 4131: + return "രာ္രာ" case 4137: return "သြ" case 4138: - return "သြော်" + return "သြେာ်" + case 4145: + return "େ" case 4150: return "̊" case 4152: @@ -1758,6 +1940,10 @@ func GetReplacement(input rune) string { return "o" case 4171: return "၊၊" + case 4186: + return "c" + case 4193: + return "ရှ" case 4197: return "၁" case 4198: @@ -1769,11 +1955,15 @@ func GetReplacement(input rune) string { case 4222: return "ၽှ" case 4225: - return "ဂှ" + return "രှ" case 4254: return "ႃ̊" case 4256: return "Ꞇ" + case 4311: + return "oာ" + case 4312: + return "ര" case 4327: return "y" case 4339: @@ -2856,6 +3046,8 @@ func GetReplacement(input rune) string { return "᜕" case 5941: return "/" + case 6031: + return "ដ" case 6051: return "អ" case 6071: @@ -2880,6 +3072,8 @@ func GetReplacement(input rune) string { return "๏" case 6106: return "๛" + case 6112: + return "o" case 6147: return ":" case 6153: @@ -2964,6 +3158,14 @@ func GetReplacement(input rune) string { return "ۛ" case 6839: return "̨" + case 6873: + return "᫆" + case 6882: + return "̄" + case 6887: + return "\u1ae5" + case 6888: + return "̄̄" case 6994: return "ᬍ" case 6995: @@ -3084,6 +3286,8 @@ func GetReplacement(input rune) string { return "ᣔ" case 7611: return "ᙆ" + case 7656: + return "\u1ada" case 7662: return "ⷬ" case 7747: @@ -3258,6 +3462,8 @@ func GetReplacement(input rune) string { return "lt" case 8381: return "Ք" + case 8385: + return "رىlل" case 8411: return "ۛ" case 8448: @@ -3460,6 +3666,10 @@ func GetReplacement(input rune) string { return "ᛚ" case 8639: return "ᛐ" + case 8644: + return "\U0001f8d0" + case 8652: + return "\U0001f8d1" case 8704: return "Ɐ" case 8707: @@ -3832,6 +4042,8 @@ func GetReplacement(input rune) string { return "┌" case 9507: return "├" + case 9578: + return "ǂ" case 9585: return "/" case 9587: @@ -3881,11 +4093,15 @@ func GetReplacement(input rune) string { case 9765: return "𐦞" case 9776: - return "Ⲷ" + return "Ξ" case 9784: return "⎈" case 9806: return "≏" + case 9815: + return "\U0001fa55" + case 9821: + return "\U0001fa57" case 9826: return "ᛜ" case 9833: @@ -3932,6 +4148,8 @@ func GetReplacement(input rune) string { return "❬" case 10217: return "❭" + case 10495: + return "\U0001cee0" case 10539: return "x" case 10540: @@ -3948,6 +4166,8 @@ func GetReplacement(input rune) string { return "ⵂ" case 10672: return "⍉" + case 10677: + return "\U0001cef0" case 10686: return "⌾" case 10692: @@ -4040,6 +4260,8 @@ func GetReplacement(input rune) string { return "///" case 11005: return "//" + case 11158: + return "=᪲" case 11244: return "↞" case 11245: @@ -4052,6 +4274,10 @@ func GetReplacement(input rune) string { return "H̩" case 11369: return "K̩" + case 11394: + return "B" + case 11395: + return "ʙ" case 11396: return "Γ" case 11397: @@ -4062,26 +4288,52 @@ func GetReplacement(input rune) string { return "Ꞓ" case 11401: return "ꞓ" + case 11403: + return "ς" + case 11404: + return "Ⱬ" + case 11405: + return "ⱬ" case 11406: return "H" + case 11407: + return "ʜ" + case 11408: + return "O̵" + case 11409: + return "o̵" case 11410: return "l" + case 11411: + return "i" case 11412: return "K" case 11413: return "ĸ" case 11414: return "λ" + case 11415: + return "ʌ" case 11416: return "M" + case 11417: + return "ʍ" case 11418: return "N" + case 11419: + return "ɴ" + case 11420: + return "3" + case 11421: + return "ʓ" case 11422: return "O" case 11423: return "o" case 11424: return "Π" + case 11425: + return "π" case 11426: return "P" case 11427: @@ -4092,8 +4344,12 @@ func GetReplacement(input rune) string { return "c" case 11430: return "T" + case 11431: + return "ᴛ" case 11432: return "Y" + case 11433: + return "y" case 11434: return "Φ" case 11435: @@ -4104,34 +4360,76 @@ func GetReplacement(input rune) string { return "χ" case 11438: return "Ψ" + case 11439: + return "ψ" + case 11440: + return "Ꙍ" case 11441: return "ω" + case 11442: + return "-̇" + case 11443: + return "-̇" case 11444: return "<·" + case 11445: + return "<·" + case 11446: + return "Ξ" + case 11447: + return "≡" case 11450: return "-" + case 11451: + return "-" case 11452: return "Ш" case 11453: - return "ш" + return "w" + case 11456: + return "Ք" + case 11457: + return "ϼ" + case 11460: + return "3" + case 11461: + return "ȝ" case 11462: return "/" + case 11463: + return "/" case 11466: return "9" + case 11467: + return "9" case 11468: return "3" case 11469: return "ȝ" + case 11470: + return "P" + case 11471: + return "p" case 11472: return "L" case 11473: return "ʟ" case 11474: return "6" + case 11475: + return "6" case 11484: - return "Ϭ" + return "6" + case 11485: + return "ẟ" + case 11488: + return "ɸ" + case 11489: + return "ɸ" case 11492: return "ϗ" + case 11496: + return "Ք" case 11497: return "☧" case 11513: @@ -4174,6 +4472,8 @@ func GetReplacement(input rune) string { return "̊" case 11757: return "ͨ" + case 11758: + return "\u1adb" case 11759: return "ͯ" case 11766: @@ -4313,7 +4613,7 @@ func GetReplacement(input rune) string { case 11984: return "钅" case 11985: - return "長" + return "ᄐーᄂᄌ" case 11986: return "镸" case 11987: @@ -4543,7 +4843,7 @@ func GetReplacement(input rune) string { case 12120: return "爻" case 12121: - return "爿" + return "누丨" case 12122: return "片" case 12123: @@ -4699,7 +4999,7 @@ func GetReplacement(input rune) string { case 12198: return "金" case 12199: - return "長" + return "ᄐーᄂᄌ" case 12200: return "門" case 12201: @@ -5342,16 +5642,32 @@ func GetReplacement(input rune) string { return "㖈" case 17440: return "㬻" + case 18069: + return "𧢮" case 19968: return "ー" + case 19989: + return "조" + case 19995: + return "ᄉᄉー" case 20022: return "\\" case 20031: return "/" + case 20110: + return "𛄢" + case 20170: + return "ᄉーᄀ" case 20482: return "併" case 20540: return "値" + case 20818: + return "\U00016ff3" + case 21343: + return "마" + case 21512: + return "ᄉーᄆ" case 21855: return "啓" case 22231: @@ -5368,6 +5684,8 @@ func GetReplacement(input rune) string { return "帡" case 24144: return "㬺" + case 24888: + return "\U0002b73f" case 25144: return "戶" case 25609: @@ -5388,6 +5706,8 @@ func GetReplacement(input rune) string { return "榝" case 28505: return "溈" + case 29247: + return "누丨" case 30799: return "研" case 32118: @@ -5432,6 +5752,8 @@ func GetReplacement(input rune) string { return "郎" case 37806: return "鎭" + case 38263: + return "ᄐーᄂᄌ" case 38584: return "隷" case 40515: @@ -5698,6 +6020,12 @@ func GetReplacement(input rune) string { return "Ꙍ" case 42935: return "ω" + case 42959: + return "\ua7ce" + case 42962: + return "ꟓ" + case 42964: + return "ꟕ" case 42966: return "ß" case 42970: @@ -5706,6 +6034,8 @@ func GetReplacement(input rune) string { return "λ" case 42972: return "Ʌ̸" + case 42993: + return "ᣵ" case 42999: return "ー" case 43056: @@ -7021,13 +7351,13 @@ func GetReplacement(input rune) string { case 64349: return "ڀ" case 64350: - return "ٺ" + return "ت" case 64351: - return "ٺ" + return "ت" case 64352: - return "ٺ" + return "ت" case 64353: - return "ٺ" + return "ت" case 64354: return "ٿ" case 64355: @@ -8575,7 +8905,7 @@ func GetReplacement(input rune) string { case 65945: return "l̵l̵" case 65952: - return "⳨" + return "Ք" case 66178: return "B" case 66181: @@ -8770,6 +9100,12 @@ func GetReplacement(input rune) string { return "𐲥" case 68860: return "𐲂" + case 69318: + return "ن" + case 69319: + return "ڀ" + case 69328: + return "°̲" case 69819: return "॰" case 70087: @@ -8865,7 +9201,7 @@ func GetReplacement(input rune) string { case 70853: return "ẇ" case 70864: - return "O" + return "o" case 70865: return "১" case 70866: @@ -9002,14 +9338,36 @@ func GetReplacement(input rune) string { return "𑫳𑫳𑫯" case 72440: return "𑫳𑫳𑫰" + case 72544: + return "ऺ" + case 72550: + return "̆" case 72770: return "𑱁𑱁" case 72882: return "𑲪" + case 73177: + return ":" + case 73178: + return "l" + case 73184: + return "O" + case 73185: + return "l" case 73784: return "𐎚" case 78585: return "𐦞" + case 93862: + return "Π" + case 93866: + return "l" + case 93878: + return "b" + case 93889: + return "π" + case 93905: + return "ƅ" case 93959: return "Γ" case 93960: @@ -9048,6 +9406,8 @@ func GetReplacement(input rune) string { return "'" case 94034: return "'" + case 94194: + return "儿" case 117974: return "A" case 117975: @@ -9120,6 +9480,10 @@ func GetReplacement(input rune) string { return "8" case 118009: return "9" + case 118011: + return "🛸" + case 118511: + return "ⵂ" case 119060: return "{" case 119149: @@ -11170,6 +11534,10 @@ func GetReplacement(input rune) string { return "8" case 120831: return "9" + case 124649: + return "+" + case 124654: + return "᫈" case 125127: return "l" case 125128: @@ -11570,6 +11938,26 @@ func GetReplacement(input rune) string { return "☾" case 127769: return "☽" + case 127795: + return "\U0001cebc" + case 127822: + return "\U0001cebd" + case 127823: + return "\U0001cebd" + case 127826: + return "\U0001cebe" + case 127827: + return "\U0001cebf" + case 127863: + return "\U0001ceba" + case 127970: + return "\U0001cebb" + case 128013: + return "\U0001ccfa" + case 128067: + return "\U0001ccfc" + case 128276: + return "\U0001fbfa" case 128768: return "QE" case 128769: @@ -11628,8 +12016,38 @@ func GetReplacement(input rune) string { return "8" case 130041: return "9" + case 132724: + return "凵" + case 136499: + return "壷" + case 136583: + return "多" + case 136871: + return "𡚨" case 139240: return "❬" + case 140549: + return "徚" + case 146752: + return "涅" + case 149757: + return "玥" + case 151834: + return "𥄙" + case 154324: + return "贛" + case 157085: + return "𦖨" + case 158982: + return "𦰶" + case 175813: + return "𤠔" + case 177978: + return "峀" + case 177982: + return "𣍟" + case 184673: + return "卑" case 194560: return "丽" case 194561: @@ -12714,6 +13132,8 @@ func GetReplacement(input rune) string { return "鼻" case 195101: return "𪘀" + case 204412: + return "緇" default: return "" diff --git a/vendor/go.mau.fi/util/dbutil/log.go b/vendor/go.mau.fi/util/dbutil/log.go index 918c79b..017420f 100644 --- a/vendor/go.mau.fi/util/dbutil/log.go +++ b/vendor/go.mau.fi/util/dbutil/log.go @@ -3,6 +3,7 @@ package dbutil import ( "context" "regexp" + "runtime" "strings" "time" @@ -92,12 +93,14 @@ func (z zeroLogger) DoUpgrade(from, to int, message string, txn TxnMode) { var whitespaceRegex = regexp.MustCompile(`\s+`) +var GlobalSafeQueryLog bool + func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args []any, nrows int, duration time.Duration, err error) { log := zerolog.Ctx(ctx) if log.GetLevel() == zerolog.Disabled || log == zerolog.DefaultContextLogger { log = z.l } - if (!z.TraceLogAllQueries || log.GetLevel() != zerolog.TraceLevel) && duration < 1*time.Second { + if (!z.TraceLogAllQueries || log.GetLevel() != zerolog.TraceLevel) && !GlobalSafeQueryLog && duration < 1*time.Second { return } if nrows > -1 { @@ -105,13 +108,32 @@ func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args log = &rowLog } query = strings.TrimSpace(whitespaceRegex.ReplaceAllLiteralString(query, " ")) - log.Trace(). - Err(err). - Int64("duration_µs", duration.Microseconds()). - Str("method", method). - Str("query", query). - Interface("query_args", args). - Msg("Query") + callerSkipFrame := z.CallerSkipFrame + if GlobalSafeQueryLog || duration > 1*time.Second { + for ; callerSkipFrame < 10; callerSkipFrame++ { + _, filename, _, _ := runtime.Caller(callerSkipFrame) + if !strings.Contains(filename, "/dbutil/") { + break + } + } + } + if GlobalSafeQueryLog { + log.Debug(). + Err(err). + Int64("duration_µs", duration.Microseconds()). + Str("method", method). + Str("query", query). + Caller(callerSkipFrame). + Msg("Query") + } else { + log.Trace(). + Err(err). + Int64("duration_µs", duration.Microseconds()). + Str("method", method). + Str("query", query). + Interface("query_args", args). + Msg("Query") + } if duration >= 1*time.Second { evt := log.Warn(). Float64("duration_seconds", duration.Seconds()). @@ -119,7 +141,7 @@ func (z zeroLogger) QueryTiming(ctx context.Context, method, query string, args Str("method", method). Str("query", query) if z.Caller { - evt = evt.Caller(z.CallerSkipFrame) + evt = evt.Caller(callerSkipFrame) } evt.Msg("Query took long") } diff --git a/vendor/go.mau.fi/util/dbutil/transaction.go b/vendor/go.mau.fi/util/dbutil/transaction.go index d010ea5..7abd329 100644 --- a/vendor/go.mau.fi/util/dbutil/transaction.go +++ b/vendor/go.mau.fi/util/dbutil/transaction.go @@ -120,7 +120,11 @@ func (db *Database) DoTxn(ctx context.Context, opts *TxnOptions, fn func(ctx con log.Trace().Err(err).Msg("Failed to begin transaction") return exerrors.NewDualError(ErrTxnBegin, err) } - log.Trace().Msg("Transaction started") + logLevel := zerolog.TraceLevel + if GlobalSafeQueryLog { + logLevel = zerolog.DebugLevel + } + log.WithLevel(logLevel).Msg("Transaction started") tx.noTotalLog = true ctx = log.WithContext(ctx) ctx = context.WithValue(ctx, db.txnCtxKey, tx) @@ -131,16 +135,16 @@ func (db *Database) DoTxn(ctx context.Context, opts *TxnOptions, fn func(ctx con if rollbackErr != nil { log.Warn().Err(rollbackErr).Msg("Rollback after transaction error failed") } else { - log.Trace().Msg("Rollback successful") + log.WithLevel(logLevel).Msg("Rollback successful") } return err } err = tx.Commit() if err != nil { - log.Trace().Err(err).Msg("Commit failed") + log.WithLevel(logLevel).Err(err).Msg("Commit failed") return exerrors.NewDualError(ErrTxnCommit, err) } - log.Trace().Msg("Commit successful") + log.WithLevel(logLevel).Msg("Commit successful") return nil } diff --git a/vendor/go.mau.fi/util/exmaps/set.go b/vendor/go.mau.fi/util/exmaps/set.go new file mode 100644 index 0000000..45af230 --- /dev/null +++ b/vendor/go.mau.fi/util/exmaps/set.go @@ -0,0 +1,89 @@ +// Copyright (c) 2025 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exmaps + +import ( + "iter" +) + +// AbstractSet is an interface implemented by [Set] and [exsync.Set] +type AbstractSet[T comparable] interface { + Add(item T) bool + Has(item T) bool + Pop(item T) bool + Remove(item T) + Size() int + AsList() []T + Iter() iter.Seq[T] +} + +type empty = struct{} + +var emptyVal = empty{} + +// Set is a generic set type based on a map. It is not thread-safe, use [exsync.Set] for a thread-safe variant. +type Set[T comparable] map[T]empty + +var _ AbstractSet[int] = (Set[int])(nil) + +func NewSetWithItems[T comparable](items []T) Set[T] { + s := make(Set[T], len(items)) + for _, item := range items { + s[item] = emptyVal + } + return s +} + +func (s Set[T]) Size() int { + return len(s) +} + +func (s Set[T]) Add(item T) bool { + _, exists := s[item] + if !exists { + s[item] = emptyVal + return true + } + return false +} + +func (s Set[T]) Remove(item T) { + delete(s, item) +} + +func (s Set[T]) Pop(item T) bool { + _, exists := s[item] + if exists { + delete(s, item) + } + return exists +} + +func (s Set[T]) Has(item T) bool { + _, exists := s[item] + return exists +} + +func (s Set[T]) AsList() []T { + result := make([]T, len(s)) + i := 0 + for item := range s { + result[i] = item + i++ + } + return result +} + +func (s Set[T]) Iter() iter.Seq[T] { + return func(yield func(T) bool) { + for item := range s { + if !yield(item) { + return + } + } + } +} diff --git a/vendor/go.mau.fi/util/exslices/delete.go b/vendor/go.mau.fi/util/exslices/delete.go new file mode 100644 index 0000000..877226b --- /dev/null +++ b/vendor/go.mau.fi/util/exslices/delete.go @@ -0,0 +1,38 @@ +// Copyright (c) 2025 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exslices + +import ( + "slices" +) + +// FastDeleteIndex deletes the item at the given index without preserving slice order. +// This is faster than normal deletion, as it doesn't need to copy all elements after the deleted index. +func FastDeleteIndex[T any](s []T, index int) []T { + s[index] = s[len(s)-1] + clear(s[len(s)-1:]) + return s[:len(s)-1] +} + +// FastDeleteItem finds the first index of the given item in the slice and deletes it without preserving slice order. +// This is faster than normal deletion, as it doesn't need to copy all elements after the deleted index. +func FastDeleteItem[T comparable](s []T, item T) []T { + index := slices.Index(s, item) + if index < 0 { + return s + } + return FastDeleteIndex(s, index) +} + +// DeleteItem finds the first index of the given item in the slice and deletes it. +func DeleteItem[T comparable](s []T, item T) []T { + index := slices.Index(s, item) + if index < 0 { + return s + } + return slices.Delete(s, index, index+1) +} diff --git a/vendor/go.mau.fi/util/exslices/stack.go b/vendor/go.mau.fi/util/exslices/stack.go new file mode 100644 index 0000000..ac0754c --- /dev/null +++ b/vendor/go.mau.fi/util/exslices/stack.go @@ -0,0 +1,80 @@ +// Copyright (c) 2024 Tulir Asokan +// +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +package exslices + +import ( + "iter" +) + +type Stack[T comparable] []T + +func (s *Stack[T]) Push(v ...T) { + *s = append(*s, v...) +} + +// Peek returns the top item from the stack without removing it. +func (s *Stack[T]) Peek() (v T, ok bool) { + return s.PeekN(1) +} + +// PeekN returns the nth item from the top of the stack (1-based). +func (s *Stack[T]) PeekN(n int) (v T, ok bool) { + if len(*s) < n { + return + } + v = (*s)[len(*s)-n] + ok = true + return +} + +// Pop removes and returns the top item from the stack. +func (s *Stack[T]) Pop() (v T, ok bool) { + v, ok = s.Peek() + if ok { + *s = (*s)[:len(*s)-1] + } + return +} + +func (s *Stack[T]) PeekValue() T { + v, _ := s.Peek() + return v +} + +func (s *Stack[T]) PopValue() T { + v, _ := s.Pop() + return v +} + +// Index returns the highest index of the given value in the stack, or -1 if not found. +func (s *Stack[T]) Index(val T) int { + for i := len(*s) - 1; i >= 0; i-- { + if (*s)[i] == val { + return i + } + } + return -1 +} + +// Has returns whether the given value is in the stack. +func (s *Stack[T]) Has(val T) bool { + return s.Index(val) != -1 +} + +func (s *Stack[T]) PopIter() iter.Seq[T] { + return func(yield func(T) bool) { + for { + v, ok := s.Pop() + if !ok { + return + } + if !yield(v) { + return + } + } + } +} diff --git a/vendor/go.mau.fi/util/exstrings/stringutil.go b/vendor/go.mau.fi/util/exstrings/stringutil.go index 4fe1ba4..110f1c6 100644 --- a/vendor/go.mau.fi/util/exstrings/stringutil.go +++ b/vendor/go.mau.fi/util/exstrings/stringutil.go @@ -9,6 +9,7 @@ package exstrings import ( "crypto/sha256" "crypto/subtle" + "slices" "strings" "unsafe" ) @@ -102,3 +103,20 @@ func LongestSequenceOfFunc(a string, fn func(b rune) int) int { } return maxCount } + +func LongestCommonPrefix(in []string) string { + if len(in) == 0 { + return "" + } else if len(in) == 1 { + return in[0] + } + + minStr := slices.Min(in) + maxStr := slices.Max(in) + for i := 0; i < len(minStr) && i < len(maxStr); i++ { + if minStr[i] != maxStr[i] { + return minStr[:i] + } + } + return minStr +} diff --git a/vendor/go.mau.fi/util/exsync/syncmap.go b/vendor/go.mau.fi/util/exsync/syncmap.go index 477cd0a..b2013f2 100644 --- a/vendor/go.mau.fi/util/exsync/syncmap.go +++ b/vendor/go.mau.fi/util/exsync/syncmap.go @@ -71,6 +71,17 @@ func (sm *Map[Key, Value]) Get(key Key) (value Value, ok bool) { return } +// GetDefault gets a value in the map, or the given default value if there's no such key. +func (sm *Map[Key, Value]) GetDefault(key Key, def Value) Value { + sm.lock.RLock() + value, ok := sm.data[key] + sm.lock.RUnlock() + if ok { + return value + } + return def +} + // GetOrSet gets a value in the map if the key already exists, otherwise inserts the given value and returns it. // // The boolean return parameter is true if the key already exists, and false if the given value was inserted. diff --git a/vendor/go.mau.fi/util/exsync/syncset.go b/vendor/go.mau.fi/util/exsync/syncset.go index 906a145..b6ff07a 100644 --- a/vendor/go.mau.fi/util/exsync/syncset.go +++ b/vendor/go.mau.fi/util/exsync/syncset.go @@ -9,6 +9,8 @@ package exsync import ( "iter" "sync" + + "go.mau.fi/util/exmaps" ) type empty struct{} @@ -21,6 +23,8 @@ type Set[T comparable] struct { l sync.RWMutex } +var _ exmaps.AbstractSet[int] = (*Set[int])(nil) + // NewSet constructs a Set with an empty map. func NewSet[T comparable]() *Set[T] { return NewSetWithMap[T](make(map[T]empty)) diff --git a/vendor/golang.org/x/crypto/argon2/argon2.go b/vendor/golang.org/x/crypto/argon2/argon2.go index 29f0a2d..2b65ec9 100644 --- a/vendor/golang.org/x/crypto/argon2/argon2.go +++ b/vendor/golang.org/x/crypto/argon2/argon2.go @@ -6,7 +6,7 @@ // Argon2 was selected as the winner of the Password Hashing Competition and can // be used to derive cryptographic keys from passwords. // -// For a detailed specification of Argon2 see [1]. +// For a detailed specification of Argon2 see [argon2-specs.pdf]. // // If you aren't sure which function you need, use Argon2id (IDKey) and // the parameter recommendations for your scenario. @@ -17,7 +17,7 @@ // It uses data-independent memory access, which is preferred for password // hashing and password-based key derivation. Argon2i requires more passes over // memory than Argon2id to protect from trade-off attacks. The recommended -// parameters (taken from [2]) for non-interactive operations are time=3 and to +// parameters (taken from [RFC 9106 Section 7.3]) for non-interactive operations are time=3 and to // use the maximum available memory. // // # Argon2id @@ -27,11 +27,11 @@ // half of the first iteration over the memory and data-dependent memory access // for the rest. Argon2id is side-channel resistant and provides better brute- // force cost savings due to time-memory tradeoffs than Argon2i. The recommended -// parameters for non-interactive operations (taken from [2]) are time=1 and to +// parameters for non-interactive operations (taken from [RFC 9106 Section 7.3]) are time=1 and to // use the maximum available memory. // -// [1] https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf -// [2] https://tools.ietf.org/html/draft-irtf-cfrg-argon2-03#section-9.3 +// [argon2-specs.pdf]: https://github.com/P-H-C/phc-winner-argon2/blob/master/argon2-specs.pdf +// [RFC 9106 Section 7.3]: https://www.rfc-editor.org/rfc/rfc9106.html#section-7.3 package argon2 import ( @@ -59,7 +59,7 @@ const ( // // key := argon2.Key([]byte("some password"), salt, 3, 32*1024, 4, 32) // -// The draft RFC recommends[2] time=3, and memory=32*1024 is a sensible number. +// [RFC 9106 Section 7.3] recommends time=3, and memory=32*1024 as a sensible number. // If using that amount of memory (32 MB) is not possible in some contexts then // the time parameter can be increased to compensate. // @@ -69,6 +69,8 @@ const ( // adjusted to the number of available CPUs. The cost parameters should be // increased as memory latency and CPU parallelism increases. Remember to get a // good random salt. +// +// [RFC 9106 Section 7.3]: https://www.rfc-editor.org/rfc/rfc9106.html#section-7.3 func Key(password, salt []byte, time, memory uint32, threads uint8, keyLen uint32) []byte { return deriveKey(argon2i, password, salt, nil, nil, time, memory, threads, keyLen) } @@ -83,7 +85,7 @@ func Key(password, salt []byte, time, memory uint32, threads uint8, keyLen uint3 // // key := argon2.IDKey([]byte("some password"), salt, 1, 64*1024, 4, 32) // -// The draft RFC recommends[2] time=1, and memory=64*1024 is a sensible number. +// [RFC 9106 Section 7.3] recommends time=1, and memory=64*1024 as a sensible number. // If using that amount of memory (64 MB) is not possible in some contexts then // the time parameter can be increased to compensate. // @@ -93,6 +95,8 @@ func Key(password, salt []byte, time, memory uint32, threads uint8, keyLen uint3 // adjusted to the numbers of available CPUs. The cost parameters should be // increased as memory latency and CPU parallelism increases. Remember to get a // good random salt. +// +// [RFC 9106 Section 7.3]: https://www.rfc-editor.org/rfc/rfc9106.html#section-7.3 func IDKey(password, salt []byte, time, memory uint32, threads uint8, keyLen uint32) []byte { return deriveKey(argon2id, password, salt, nil, nil, time, memory, threads, keyLen) } diff --git a/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s b/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s index 7dd2638..769af38 100644 --- a/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s +++ b/vendor/golang.org/x/crypto/chacha20/chacha_arm64.s @@ -29,7 +29,7 @@ loop: MOVD $NUM_ROUNDS, R21 VLD1 (R11), [V30.S4, V31.S4] - // load contants + // load constants // VLD4R (R10), [V0.S4, V1.S4, V2.S4, V3.S4] WORD $0x4D60E940 diff --git a/vendor/golang.org/x/crypto/ssh/keys.go b/vendor/golang.org/x/crypto/ssh/keys.go index a035956..47a0753 100644 --- a/vendor/golang.org/x/crypto/ssh/keys.go +++ b/vendor/golang.org/x/crypto/ssh/keys.go @@ -1490,6 +1490,7 @@ type openSSHEncryptedPrivateKey struct { NumKeys uint32 PubKey []byte PrivKeyBlock []byte + Rest []byte `ssh:"rest"` } type openSSHPrivateKey struct { diff --git a/vendor/golang.org/x/crypto/ssh/messages.go b/vendor/golang.org/x/crypto/ssh/messages.go index 251b9d0..ab22c3d 100644 --- a/vendor/golang.org/x/crypto/ssh/messages.go +++ b/vendor/golang.org/x/crypto/ssh/messages.go @@ -792,7 +792,7 @@ func marshalString(to []byte, s []byte) []byte { return to[len(s):] } -var bigIntType = reflect.TypeOf((*big.Int)(nil)) +var bigIntType = reflect.TypeFor[*big.Int]() // Decode a packet into its corresponding message. func decode(packet []byte) (interface{}, error) { diff --git a/vendor/golang.org/x/crypto/ssh/ssh_gss.go b/vendor/golang.org/x/crypto/ssh/ssh_gss.go index 24bd7c8..a6249a1 100644 --- a/vendor/golang.org/x/crypto/ssh/ssh_gss.go +++ b/vendor/golang.org/x/crypto/ssh/ssh_gss.go @@ -106,6 +106,13 @@ func parseGSSAPIPayload(payload []byte) (*userAuthRequestGSSAPI, error) { if !ok { return nil, errors.New("parse uint32 failed") } + // Each ASN.1 encoded OID must have a minimum + // of 2 bytes; 64 maximum mechanisms is an + // arbitrary, but reasonable ceiling. + const maxMechs = 64 + if n > maxMechs || int(n)*2 > len(rest) { + return nil, errors.New("invalid mechanism count") + } s := &userAuthRequestGSSAPI{ N: n, OIDS: make([]asn1.ObjectIdentifier, n), @@ -122,7 +129,6 @@ func parseGSSAPIPayload(payload []byte) (*userAuthRequestGSSAPI, error) { if rest, err = asn1.Unmarshal(desiredMech, &s.OIDS[i]); err != nil { return nil, err } - } return s, nil } diff --git a/vendor/golang.org/x/crypto/ssh/streamlocal.go b/vendor/golang.org/x/crypto/ssh/streamlocal.go index b171b33..152470f 100644 --- a/vendor/golang.org/x/crypto/ssh/streamlocal.go +++ b/vendor/golang.org/x/crypto/ssh/streamlocal.go @@ -44,7 +44,7 @@ func (c *Client) ListenUnix(socketPath string) (net.Listener, error) { if !ok { return nil, errors.New("ssh: streamlocal-forward@openssh.com request denied by peer") } - ch := c.forwards.add(&net.UnixAddr{Name: socketPath, Net: "unix"}) + ch := c.forwards.add("unix", socketPath) return &unixListener{socketPath, c, ch}, nil } @@ -96,7 +96,7 @@ func (l *unixListener) Accept() (net.Conn, error) { // Close closes the listener. func (l *unixListener) Close() error { // this also closes the listener. - l.conn.forwards.remove(&net.UnixAddr{Name: l.socketPath, Net: "unix"}) + l.conn.forwards.remove("unix", l.socketPath) m := streamLocalChannelForwardMsg{ l.socketPath, } diff --git a/vendor/golang.org/x/crypto/ssh/tcpip.go b/vendor/golang.org/x/crypto/ssh/tcpip.go index 93d844f..78c41fe 100644 --- a/vendor/golang.org/x/crypto/ssh/tcpip.go +++ b/vendor/golang.org/x/crypto/ssh/tcpip.go @@ -11,6 +11,7 @@ import ( "io" "math/rand" "net" + "net/netip" "strconv" "strings" "sync" @@ -22,14 +23,21 @@ import ( // the returned net.Listener. The listener must be serviced, or the // SSH connection may hang. // N must be "tcp", "tcp4", "tcp6", or "unix". +// +// If the address is a hostname, it is sent to the remote peer as-is, without +// being resolved locally, and the Listener Addr method will return a zero IP. func (c *Client) Listen(n, addr string) (net.Listener, error) { switch n { case "tcp", "tcp4", "tcp6": - laddr, err := net.ResolveTCPAddr(n, addr) + host, portStr, err := net.SplitHostPort(addr) if err != nil { return nil, err } - return c.ListenTCP(laddr) + port, err := strconv.ParseInt(portStr, 10, 32) + if err != nil { + return nil, err + } + return c.listenTCPInternal(host, int(port)) case "unix": return c.ListenUnix(addr) default: @@ -102,15 +110,24 @@ func (c *Client) handleForwards() { // ListenTCP requests the remote peer open a listening socket // on laddr. Incoming connections will be available by calling // Accept on the returned net.Listener. +// +// ListenTCP accepts an IP address, to provide a hostname use [Client.Listen] +// with "tcp", "tcp4", or "tcp6" network instead. func (c *Client) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) { c.handleForwardsOnce.Do(c.handleForwards) if laddr.Port == 0 && isBrokenOpenSSHVersion(string(c.ServerVersion())) { return c.autoPortListenWorkaround(laddr) } + return c.listenTCPInternal(laddr.IP.String(), laddr.Port) +} + +func (c *Client) listenTCPInternal(host string, port int) (net.Listener, error) { + c.handleForwardsOnce.Do(c.handleForwards) + m := channelForwardMsg{ - laddr.IP.String(), - uint32(laddr.Port), + host, + uint32(port), } // send message ok, resp, err := c.SendRequest("tcpip-forward", true, Marshal(&m)) @@ -123,20 +140,33 @@ func (c *Client) ListenTCP(laddr *net.TCPAddr) (net.Listener, error) { // If the original port was 0, then the remote side will // supply a real port number in the response. - if laddr.Port == 0 { + if port == 0 { var p struct { Port uint32 } if err := Unmarshal(resp, &p); err != nil { return nil, err } - laddr.Port = int(p.Port) + port = int(p.Port) } + // Construct a local address placeholder for the remote listener. If the + // original host is an IP address, preserve it so that Listener.Addr() + // reports the same IP. If the host is a hostname or cannot be parsed as an + // IP, fall back to IPv4zero. The port field is always set, even if the + // original port was 0, because in that case the remote server will assign + // one, allowing callers to determine which port was selected. + ip := net.IPv4zero + if parsed, err := netip.ParseAddr(host); err == nil { + ip = net.IP(parsed.AsSlice()) + } + laddr := &net.TCPAddr{ + IP: ip, + Port: port, + } + addr := net.JoinHostPort(host, strconv.FormatInt(int64(port), 10)) + ch := c.forwards.add("tcp", addr) - // Register this forward, using the port number we obtained. - ch := c.forwards.add(laddr) - - return &tcpListener{laddr, c, ch}, nil + return &tcpListener{laddr, addr, c, ch}, nil } // forwardList stores a mapping between remote @@ -149,8 +179,9 @@ type forwardList struct { // forwardEntry represents an established mapping of a laddr on a // remote ssh server to a channel connected to a tcpListener. type forwardEntry struct { - laddr net.Addr - c chan forward + addr string // host:port or socket path + network string // tcp or unix + c chan forward } // forward represents an incoming forwarded tcpip connection. The @@ -161,12 +192,13 @@ type forward struct { raddr net.Addr // the raddr of the incoming connection } -func (l *forwardList) add(addr net.Addr) chan forward { +func (l *forwardList) add(n, addr string) chan forward { l.Lock() defer l.Unlock() f := forwardEntry{ - laddr: addr, - c: make(chan forward, 1), + addr: addr, + network: n, + c: make(chan forward, 1), } l.entries = append(l.entries, f) return f.c @@ -185,19 +217,20 @@ func parseTCPAddr(addr string, port uint32) (*net.TCPAddr, error) { if port == 0 || port > 65535 { return nil, fmt.Errorf("ssh: port number out of range: %d", port) } - ip := net.ParseIP(string(addr)) - if ip == nil { + ip, err := netip.ParseAddr(addr) + if err != nil { return nil, fmt.Errorf("ssh: cannot parse IP address %q", addr) } - return &net.TCPAddr{IP: ip, Port: int(port)}, nil + return &net.TCPAddr{IP: net.IP(ip.AsSlice()), Port: int(port)}, nil } func (l *forwardList) handleChannels(in <-chan NewChannel) { for ch := range in { var ( - laddr net.Addr - raddr net.Addr - err error + addr string + network string + raddr net.Addr + err error ) switch channelType := ch.ChannelType(); channelType { case "forwarded-tcpip": @@ -207,40 +240,34 @@ func (l *forwardList) handleChannels(in <-chan NewChannel) { continue } - // RFC 4254 section 7.2 specifies that incoming - // addresses should list the address, in string - // format. It is implied that this should be an IP - // address, as it would be impossible to connect to it - // otherwise. - laddr, err = parseTCPAddr(payload.Addr, payload.Port) - if err != nil { - ch.Reject(ConnectionFailed, err.Error()) - continue - } + // RFC 4254 section 7.2 specifies that incoming addresses should + // list the address that was connected, in string format. It is the + // same address used in the tcpip-forward request. The originator + // address is an IP address instead. + addr = net.JoinHostPort(payload.Addr, strconv.FormatUint(uint64(payload.Port), 10)) + raddr, err = parseTCPAddr(payload.OriginAddr, payload.OriginPort) if err != nil { ch.Reject(ConnectionFailed, err.Error()) continue } - + network = "tcp" case "forwarded-streamlocal@openssh.com": var payload forwardedStreamLocalPayload if err = Unmarshal(ch.ExtraData(), &payload); err != nil { ch.Reject(ConnectionFailed, "could not parse forwarded-streamlocal@openssh.com payload: "+err.Error()) continue } - laddr = &net.UnixAddr{ - Name: payload.SocketPath, - Net: "unix", - } + addr = payload.SocketPath raddr = &net.UnixAddr{ Name: "@", Net: "unix", } + network = "unix" default: panic(fmt.Errorf("ssh: unknown channel type %s", channelType)) } - if ok := l.forward(laddr, raddr, ch); !ok { + if ok := l.forward(network, addr, raddr, ch); !ok { // Section 7.2, implementations MUST reject spurious incoming // connections. ch.Reject(Prohibited, "no forward for address") @@ -252,11 +279,11 @@ func (l *forwardList) handleChannels(in <-chan NewChannel) { // remove removes the forward entry, and the channel feeding its // listener. -func (l *forwardList) remove(addr net.Addr) { +func (l *forwardList) remove(n, addr string) { l.Lock() defer l.Unlock() for i, f := range l.entries { - if addr.Network() == f.laddr.Network() && addr.String() == f.laddr.String() { + if n == f.network && addr == f.addr { l.entries = append(l.entries[:i], l.entries[i+1:]...) close(f.c) return @@ -274,11 +301,11 @@ func (l *forwardList) closeAll() { l.entries = nil } -func (l *forwardList) forward(laddr, raddr net.Addr, ch NewChannel) bool { +func (l *forwardList) forward(n, addr string, raddr net.Addr, ch NewChannel) bool { l.Lock() defer l.Unlock() for _, f := range l.entries { - if laddr.Network() == f.laddr.Network() && laddr.String() == f.laddr.String() { + if n == f.network && addr == f.addr { f.c <- forward{newCh: ch, raddr: raddr} return true } @@ -288,6 +315,7 @@ func (l *forwardList) forward(laddr, raddr net.Addr, ch NewChannel) bool { type tcpListener struct { laddr *net.TCPAddr + addr string conn *Client in <-chan forward @@ -314,13 +342,21 @@ func (l *tcpListener) Accept() (net.Conn, error) { // Close closes the listener. func (l *tcpListener) Close() error { + host, port, err := net.SplitHostPort(l.addr) + if err != nil { + return err + } + rport, err := strconv.ParseUint(port, 10, 32) + if err != nil { + return err + } m := channelForwardMsg{ - l.laddr.IP.String(), - uint32(l.laddr.Port), + host, + uint32(rport), } // this also closes the listener. - l.conn.forwards.remove(l.laddr) + l.conn.forwards.remove("tcp", l.addr) ok, _, err := l.conn.SendRequest("cancel-tcpip-forward", true, Marshal(&m)) if err == nil && !ok { err = errors.New("ssh: cancel-tcpip-forward failed") diff --git a/vendor/golang.org/x/net/http2/frame.go b/vendor/golang.org/x/net/http2/frame.go index 93bcaab..9a4bd12 100644 --- a/vendor/golang.org/x/net/http2/frame.go +++ b/vendor/golang.org/x/net/http2/frame.go @@ -280,6 +280,8 @@ type Framer struct { // lastHeaderStream is non-zero if the last frame was an // unfinished HEADERS/CONTINUATION. lastHeaderStream uint32 + // lastFrameType holds the type of the last frame for verifying frame order. + lastFrameType FrameType maxReadSize uint32 headerBuf [frameHeaderLen]byte @@ -488,30 +490,41 @@ func terminalReadFrameError(err error) bool { return err != nil } -// ReadFrame reads a single frame. The returned Frame is only valid -// until the next call to ReadFrame. +// ReadFrameHeader reads the header of the next frame. +// It reads the 9-byte fixed frame header, and does not read any portion of the +// frame payload. The caller is responsible for consuming the payload, either +// with ReadFrameForHeader or directly from the Framer's io.Reader. // -// If the frame is larger than previously set with SetMaxReadFrameSize, the -// returned error is ErrFrameTooLarge. Other errors may be of type -// ConnectionError, StreamError, or anything else from the underlying -// reader. +// If the frame is larger than previously set with SetMaxReadFrameSize, it +// returns the frame header and ErrFrameTooLarge. // -// If ReadFrame returns an error and a non-nil Frame, the Frame's StreamID -// indicates the stream responsible for the error. -func (fr *Framer) ReadFrame() (Frame, error) { +// If the returned FrameHeader.StreamID is non-zero, it indicates the stream +// responsible for the error. +func (fr *Framer) ReadFrameHeader() (FrameHeader, error) { fr.errDetail = nil - if fr.lastFrame != nil { - fr.lastFrame.invalidate() - } fh, err := readFrameHeader(fr.headerBuf[:], fr.r) if err != nil { - return nil, err + return fh, err } if fh.Length > fr.maxReadSize { if fh == invalidHTTP1LookingFrameHeader() { - return nil, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", ErrFrameTooLarge) + return fh, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", ErrFrameTooLarge) } - return nil, ErrFrameTooLarge + return fh, ErrFrameTooLarge + } + if err := fr.checkFrameOrder(fh); err != nil { + return fh, err + } + return fh, nil +} + +// ReadFrameForHeader reads the payload for the frame with the given FrameHeader. +// +// It behaves identically to ReadFrame, other than not checking the maximum +// frame size. +func (fr *Framer) ReadFrameForHeader(fh FrameHeader) (Frame, error) { + if fr.lastFrame != nil { + fr.lastFrame.invalidate() } payload := fr.getReadBuf(fh.Length) if _, err := io.ReadFull(fr.r, payload); err != nil { @@ -527,9 +540,7 @@ func (fr *Framer) ReadFrame() (Frame, error) { } return nil, err } - if err := fr.checkFrameOrder(f); err != nil { - return nil, err - } + fr.lastFrame = f if fr.logReads { fr.debugReadLoggerf("http2: Framer %p: read %v", fr, summarizeFrame(f)) } @@ -539,6 +550,24 @@ func (fr *Framer) ReadFrame() (Frame, error) { return f, nil } +// ReadFrame reads a single frame. The returned Frame is only valid +// until the next call to ReadFrame or ReadFrameBodyForHeader. +// +// If the frame is larger than previously set with SetMaxReadFrameSize, the +// returned error is ErrFrameTooLarge. Other errors may be of type +// ConnectionError, StreamError, or anything else from the underlying +// reader. +// +// If ReadFrame returns an error and a non-nil Frame, the Frame's StreamID +// indicates the stream responsible for the error. +func (fr *Framer) ReadFrame() (Frame, error) { + fh, err := fr.ReadFrameHeader() + if err != nil { + return nil, err + } + return fr.ReadFrameForHeader(fh) +} + // connError returns ConnectionError(code) but first // stashes away a public reason to the caller can optionally relay it // to the peer before hanging up on them. This might help others debug @@ -551,20 +580,19 @@ func (fr *Framer) connError(code ErrCode, reason string) error { // checkFrameOrder reports an error if f is an invalid frame to return // next from ReadFrame. Mostly it checks whether HEADERS and // CONTINUATION frames are contiguous. -func (fr *Framer) checkFrameOrder(f Frame) error { - last := fr.lastFrame - fr.lastFrame = f +func (fr *Framer) checkFrameOrder(fh FrameHeader) error { + lastType := fr.lastFrameType + fr.lastFrameType = fh.Type if fr.AllowIllegalReads { return nil } - fh := f.Header() if fr.lastHeaderStream != 0 { if fh.Type != FrameContinuation { return fr.connError(ErrCodeProtocol, fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d", fh.Type, fh.StreamID, - last.Header().Type, fr.lastHeaderStream)) + lastType, fr.lastHeaderStream)) } if fh.StreamID != fr.lastHeaderStream { return fr.connError(ErrCodeProtocol, @@ -1161,7 +1189,7 @@ var defaultRFC9218Priority = PriorityParam{ // PriorityParam struct below is a superset of both schemes. The exported // symbols are from RFC 7540 and the non-exported ones are from RFC 9218. -// PriorityParam are the stream prioritzation parameters. +// PriorityParam are the stream prioritization parameters. type PriorityParam struct { // StreamDep is a 31-bit stream identifier for the // stream that this stream depends on. Zero means no diff --git a/vendor/golang.org/x/net/http2/transport.go b/vendor/golang.org/x/net/http2/transport.go index be759b6..ccb87e6 100644 --- a/vendor/golang.org/x/net/http2/transport.go +++ b/vendor/golang.org/x/net/http2/transport.go @@ -9,6 +9,7 @@ package http2 import ( "bufio" "bytes" + "compress/flate" "compress/gzip" "context" "crypto/rand" @@ -375,11 +376,24 @@ type ClientConn struct { // completely unresponsive connection. pendingResets int + // readBeforeStreamID is the smallest stream ID that has not been followed by + // a frame read from the peer. We use this to determine when a request may + // have been sent to a completely unresponsive connection: + // If the request ID is less than readBeforeStreamID, then we have had some + // indication of life on the connection since sending the request. + readBeforeStreamID uint32 + // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. // Write to reqHeaderMu to lock it, read from it to unlock. // Lock reqmu BEFORE mu or wmu. reqHeaderMu chan struct{} + // internalStateHook reports state changes back to the net/http.ClientConn. + // Note that this is different from the user state hook registered by + // net/http.ClientConn.SetStateHook: The internal hook calls ClientConn, + // which calls the user hook. + internalStateHook func() + // wmu is held while writing. // Acquire BEFORE mu when holding both, to avoid blocking mu on network writes. // Only acquire both at the same time when changing peer settings. @@ -709,7 +723,7 @@ func canRetryError(err error) bool { func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*ClientConn, error) { if t.transportTestHooks != nil { - return t.newClientConn(nil, singleUse) + return t.newClientConn(nil, singleUse, nil) } host, _, err := net.SplitHostPort(addr) if err != nil { @@ -719,7 +733,7 @@ func (t *Transport) dialClientConn(ctx context.Context, addr string, singleUse b if err != nil { return nil, err } - return t.newClientConn(tconn, singleUse) + return t.newClientConn(tconn, singleUse, nil) } func (t *Transport) newTLSConfig(host string) *tls.Config { @@ -771,10 +785,10 @@ func (t *Transport) expectContinueTimeout() time.Duration { } func (t *Transport) NewClientConn(c net.Conn) (*ClientConn, error) { - return t.newClientConn(c, t.disableKeepAlives()) + return t.newClientConn(c, t.disableKeepAlives(), nil) } -func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, error) { +func (t *Transport) newClientConn(c net.Conn, singleUse bool, internalStateHook func()) (*ClientConn, error) { conf := configFromTransport(t) cc := &ClientConn{ t: t, @@ -796,6 +810,7 @@ func (t *Transport) newClientConn(c net.Conn, singleUse bool) (*ClientConn, erro pings: make(map[[8]byte]chan struct{}), reqHeaderMu: make(chan struct{}, 1), lastActive: time.Now(), + internalStateHook: internalStateHook, } if t.transportTestHooks != nil { t.transportTestHooks.newclientconn(cc) @@ -1036,10 +1051,7 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) } - st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && - !cc.doNotReuse && - int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && - !cc.tooIdleLocked() + st.canTakeNewRequest = maxConcurrentOkay && cc.isUsableLocked() // If this connection has never been used for a request and is closed, // then let it take a request (which will fail). @@ -1055,6 +1067,31 @@ func (cc *ClientConn) idleStateLocked() (st clientConnIdleState) { return } +func (cc *ClientConn) isUsableLocked() bool { + return cc.goAway == nil && + !cc.closed && + !cc.closing && + !cc.doNotReuse && + int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 && + !cc.tooIdleLocked() +} + +// canReserveLocked reports whether a net/http.ClientConn can reserve a slot on this conn. +// +// This follows slightly different rules than clientConnIdleState.canTakeNewRequest. +// We only permit reservations up to the conn's concurrency limit. +// This differs from ClientConn.ReserveNewRequest, which permits reservations +// past the limit when StrictMaxConcurrentStreams is set. +func (cc *ClientConn) canReserveLocked() bool { + if cc.currentRequestCountLocked() >= int(cc.maxConcurrentStreams) { + return false + } + if !cc.isUsableLocked() { + return false + } + return true +} + // currentRequestCountLocked reports the number of concurrency slots currently in use, // including active streams, reserved slots, and reset streams waiting for acknowledgement. func (cc *ClientConn) currentRequestCountLocked() int { @@ -1066,6 +1103,14 @@ func (cc *ClientConn) canTakeNewRequestLocked() bool { return st.canTakeNewRequest } +// availableLocked reports the number of concurrency slots available. +func (cc *ClientConn) availableLocked() int { + if !cc.canTakeNewRequestLocked() { + return 0 + } + return max(0, int(cc.maxConcurrentStreams)-cc.currentRequestCountLocked()) +} + // tooIdleLocked reports whether this connection has been been sitting idle // for too much wall time. func (cc *ClientConn) tooIdleLocked() bool { @@ -1090,6 +1135,7 @@ func (cc *ClientConn) closeConn() { t := time.AfterFunc(250*time.Millisecond, cc.forceCloseConn) defer t.Stop() cc.tconn.Close() + cc.maybeCallStateHook() } // A tls.Conn.Close can hang for a long time if the peer is unresponsive. @@ -1615,6 +1661,8 @@ func (cs *clientStream) cleanupWriteRequest(err error) { } bodyClosed := cs.reqBodyClosed closeOnIdle := cc.singleUse || cc.doNotReuse || cc.t.disableKeepAlives() || cc.goAway != nil + // Have we read any frames from the connection since sending this request? + readSinceStream := cc.readBeforeStreamID > cs.ID cc.mu.Unlock() if mustCloseBody { cs.reqBody.Close() @@ -1646,8 +1694,10 @@ func (cs *clientStream) cleanupWriteRequest(err error) { // // This could be due to the server becoming unresponsive. // To avoid sending too many requests on a dead connection, - // we let the request continue to consume a concurrency slot - // until we can confirm the server is still responding. + // if we haven't read any frames from the connection since + // sending this request, we let it continue to consume + // a concurrency slot until we can confirm the server is + // still responding. // We do this by sending a PING frame along with the RST_STREAM // (unless a ping is already in flight). // @@ -1658,7 +1708,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { // because it's short lived and will probably be closed before // we get the ping response. ping := false - if !closeOnIdle { + if !closeOnIdle && !readSinceStream { cc.mu.Lock() // rstStreamPingsBlocked works around a gRPC behavior: // see comment on the field for details. @@ -1692,6 +1742,7 @@ func (cs *clientStream) cleanupWriteRequest(err error) { } close(cs.donec) + cc.maybeCallStateHook() } // awaitOpenSlotForStreamLocked waits until len(streams) < maxConcurrentStreams. @@ -2744,6 +2795,7 @@ func (rl *clientConnReadLoop) streamByID(id uint32, headerOrData bool) *clientSt // See comment on ClientConn.rstStreamPingsBlocked for details. rl.cc.rstStreamPingsBlocked = false } + rl.cc.readBeforeStreamID = rl.cc.nextStreamID cs := rl.cc.streams[id] if cs != nil && !cs.readAborted { return cs @@ -2794,6 +2846,7 @@ func (rl *clientConnReadLoop) processSettings(f *SettingsFrame) error { func (rl *clientConnReadLoop) processSettingsNoWrite(f *SettingsFrame) error { cc := rl.cc + defer cc.maybeCallStateHook() cc.mu.Lock() defer cc.mu.Unlock() @@ -2974,6 +3027,7 @@ func (cc *ClientConn) Ping(ctx context.Context) error { func (rl *clientConnReadLoop) processPing(f *PingFrame) error { if f.IsAck() { cc := rl.cc + defer cc.maybeCallStateHook() cc.mu.Lock() defer cc.mu.Unlock() // If ack, notify listener if any @@ -3076,35 +3130,102 @@ type erringRoundTripper struct{ err error } func (rt erringRoundTripper) RoundTripErr() error { return rt.err } func (rt erringRoundTripper) RoundTrip(*http.Request) (*http.Response, error) { return nil, rt.err } +var errConcurrentReadOnResBody = errors.New("http2: concurrent read on response body") + // gzipReader wraps a response body so it can lazily -// call gzip.NewReader on the first call to Read +// get gzip.Reader from the pool on the first call to Read. +// After Close is called it puts gzip.Reader to the pool immediately +// if there is no Read in progress or later when Read completes. type gzipReader struct { _ incomparable body io.ReadCloser // underlying Response.Body - zr *gzip.Reader // lazily-initialized gzip reader - zerr error // sticky error + mu sync.Mutex // guards zr and zerr + zr *gzip.Reader // stores gzip reader from the pool between reads + zerr error // sticky gzip reader init error or sentinel value to detect concurrent read and read after close +} + +type eofReader struct{} + +func (eofReader) Read([]byte) (int, error) { return 0, io.EOF } +func (eofReader) ReadByte() (byte, error) { return 0, io.EOF } + +var gzipPool = sync.Pool{New: func() any { return new(gzip.Reader) }} + +// gzipPoolGet gets a gzip.Reader from the pool and resets it to read from r. +func gzipPoolGet(r io.Reader) (*gzip.Reader, error) { + zr := gzipPool.Get().(*gzip.Reader) + if err := zr.Reset(r); err != nil { + gzipPoolPut(zr) + return nil, err + } + return zr, nil +} + +// gzipPoolPut puts a gzip.Reader back into the pool. +func gzipPoolPut(zr *gzip.Reader) { + // Reset will allocate bufio.Reader if we pass it anything + // other than a flate.Reader, so ensure that it's getting one. + var r flate.Reader = eofReader{} + zr.Reset(r) + gzipPool.Put(zr) +} + +// acquire returns a gzip.Reader for reading response body. +// The reader must be released after use. +func (gz *gzipReader) acquire() (*gzip.Reader, error) { + gz.mu.Lock() + defer gz.mu.Unlock() + if gz.zerr != nil { + return nil, gz.zerr + } + if gz.zr == nil { + gz.zr, gz.zerr = gzipPoolGet(gz.body) + if gz.zerr != nil { + return nil, gz.zerr + } + } + ret := gz.zr + gz.zr, gz.zerr = nil, errConcurrentReadOnResBody + return ret, nil +} + +// release returns the gzip.Reader to the pool if Close was called during Read. +func (gz *gzipReader) release(zr *gzip.Reader) { + gz.mu.Lock() + defer gz.mu.Unlock() + if gz.zerr == errConcurrentReadOnResBody { + gz.zr, gz.zerr = zr, nil + } else { // fs.ErrClosed + gzipPoolPut(zr) + } +} + +// close returns the gzip.Reader to the pool immediately or +// signals release to do so after Read completes. +func (gz *gzipReader) close() { + gz.mu.Lock() + defer gz.mu.Unlock() + if gz.zerr == nil && gz.zr != nil { + gzipPoolPut(gz.zr) + gz.zr = nil + } + gz.zerr = fs.ErrClosed } func (gz *gzipReader) Read(p []byte) (n int, err error) { - if gz.zerr != nil { - return 0, gz.zerr + zr, err := gz.acquire() + if err != nil { + return 0, err } - if gz.zr == nil { - gz.zr, err = gzip.NewReader(gz.body) - if err != nil { - gz.zerr = err - return 0, err - } - } - return gz.zr.Read(p) + defer gz.release(zr) + + return zr.Read(p) } func (gz *gzipReader) Close() error { - if err := gz.body.Close(); err != nil { - return err - } - gz.zerr = fs.ErrClosed - return nil + gz.close() + + return gz.body.Close() } type errorReader struct{ err error } @@ -3130,9 +3251,13 @@ func registerHTTPSProtocol(t *http.Transport, rt noDialH2RoundTripper) (err erro } // noDialH2RoundTripper is a RoundTripper which only tries to complete the request -// if there's already has a cached connection to the host. +// if there's already a cached connection to the host. // (The field is exported so it can be accessed via reflect from net/http; tested // by TestNoDialH2RoundTripperType) +// +// A noDialH2RoundTripper is registered with http1.Transport.RegisterProtocol, +// and the http1.Transport can use type assertions to call non-RoundTrip methods on it. +// This lets us expose, for example, NewClientConn to net/http. type noDialH2RoundTripper struct{ *Transport } func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { @@ -3143,6 +3268,85 @@ func (rt noDialH2RoundTripper) RoundTrip(req *http.Request) (*http.Response, err return res, err } +func (rt noDialH2RoundTripper) NewClientConn(conn net.Conn, internalStateHook func()) (http.RoundTripper, error) { + tr := rt.Transport + cc, err := tr.newClientConn(conn, tr.disableKeepAlives(), internalStateHook) + if err != nil { + return nil, err + } + + // RoundTrip should block when the conn is at its concurrency limit, + // not return an error. Setting strictMaxConcurrentStreams enables this. + cc.strictMaxConcurrentStreams = true + + return netHTTPClientConn{cc}, nil +} + +// netHTTPClientConn wraps ClientConn and implements the interface net/http expects from +// the RoundTripper returned by NewClientConn. +type netHTTPClientConn struct { + cc *ClientConn +} + +func (cc netHTTPClientConn) RoundTrip(req *http.Request) (*http.Response, error) { + return cc.cc.RoundTrip(req) +} + +func (cc netHTTPClientConn) Close() error { + return cc.cc.Close() +} + +func (cc netHTTPClientConn) Err() error { + cc.cc.mu.Lock() + defer cc.cc.mu.Unlock() + if cc.cc.closed { + return errors.New("connection closed") + } + return nil +} + +func (cc netHTTPClientConn) Reserve() error { + defer cc.cc.maybeCallStateHook() + cc.cc.mu.Lock() + defer cc.cc.mu.Unlock() + if !cc.cc.canReserveLocked() { + return errors.New("connection is unavailable") + } + cc.cc.streamsReserved++ + return nil +} + +func (cc netHTTPClientConn) Release() { + defer cc.cc.maybeCallStateHook() + cc.cc.mu.Lock() + defer cc.cc.mu.Unlock() + // We don't complain if streamsReserved is 0. + // + // This is consistent with RoundTrip: both Release and RoundTrip will + // consume a reservation iff one exists. + if cc.cc.streamsReserved > 0 { + cc.cc.streamsReserved-- + } +} + +func (cc netHTTPClientConn) Available() int { + cc.cc.mu.Lock() + defer cc.cc.mu.Unlock() + return cc.cc.availableLocked() +} + +func (cc netHTTPClientConn) InFlight() int { + cc.cc.mu.Lock() + defer cc.cc.mu.Unlock() + return cc.cc.currentRequestCountLocked() +} + +func (cc *ClientConn) maybeCallStateHook() { + if cc.internalStateHook != nil { + cc.internalStateHook() + } +} + func (t *Transport) idleConnTimeout() time.Duration { // to keep things backwards compatible, we use non-zero values of // IdleConnTimeout, followed by using the IdleConnTimeout on the underlying diff --git a/vendor/golang.org/x/net/http2/writesched.go b/vendor/golang.org/x/net/http2/writesched.go index 4d3890f..7de27be 100644 --- a/vendor/golang.org/x/net/http2/writesched.go +++ b/vendor/golang.org/x/net/http2/writesched.go @@ -185,45 +185,75 @@ func (wr *FrameWriteRequest) replyToWriter(err error) { } // writeQueue is used by implementations of WriteScheduler. +// +// Each writeQueue contains a queue of FrameWriteRequests, meant to store all +// FrameWriteRequests associated with a given stream. This is implemented as a +// two-stage queue: currQueue[currPos:] and nextQueue. Removing an item is done +// by incrementing currPos of currQueue. Adding an item is done by appending it +// to the nextQueue. If currQueue is empty when trying to remove an item, we +// can swap currQueue and nextQueue to remedy the situation. +// This two-stage queue is analogous to the use of two lists in Okasaki's +// purely functional queue but without the overhead of reversing the list when +// swapping stages. +// +// writeQueue also contains prev and next, this can be used by implementations +// of WriteScheduler to construct data structures that represent the order of +// writing between different streams (e.g. circular linked list). type writeQueue struct { - s []FrameWriteRequest + currQueue []FrameWriteRequest + nextQueue []FrameWriteRequest + currPos int + prev, next *writeQueue } -func (q *writeQueue) empty() bool { return len(q.s) == 0 } +func (q *writeQueue) empty() bool { + return (len(q.currQueue) - q.currPos + len(q.nextQueue)) == 0 +} func (q *writeQueue) push(wr FrameWriteRequest) { - q.s = append(q.s, wr) + q.nextQueue = append(q.nextQueue, wr) } func (q *writeQueue) shift() FrameWriteRequest { - if len(q.s) == 0 { + if q.empty() { panic("invalid use of queue") } - wr := q.s[0] - // TODO: less copy-happy queue. - copy(q.s, q.s[1:]) - q.s[len(q.s)-1] = FrameWriteRequest{} - q.s = q.s[:len(q.s)-1] + if q.currPos >= len(q.currQueue) { + q.currQueue, q.currPos, q.nextQueue = q.nextQueue, 0, q.currQueue[:0] + } + wr := q.currQueue[q.currPos] + q.currQueue[q.currPos] = FrameWriteRequest{} + q.currPos++ return wr } +func (q *writeQueue) peek() *FrameWriteRequest { + if q.currPos < len(q.currQueue) { + return &q.currQueue[q.currPos] + } + if len(q.nextQueue) > 0 { + return &q.nextQueue[0] + } + return nil +} + // consume consumes up to n bytes from q.s[0]. If the frame is // entirely consumed, it is removed from the queue. If the frame // is partially consumed, the frame is kept with the consumed // bytes removed. Returns true iff any bytes were consumed. func (q *writeQueue) consume(n int32) (FrameWriteRequest, bool) { - if len(q.s) == 0 { + if q.empty() { return FrameWriteRequest{}, false } - consumed, rest, numresult := q.s[0].Consume(n) + consumed, rest, numresult := q.peek().Consume(n) switch numresult { case 0: return FrameWriteRequest{}, false case 1: q.shift() case 2: - q.s[0] = rest + *q.peek() = rest } return consumed, true } @@ -232,10 +262,15 @@ type writeQueuePool []*writeQueue // put inserts an unused writeQueue into the pool. func (p *writeQueuePool) put(q *writeQueue) { - for i := range q.s { - q.s[i] = FrameWriteRequest{} + for i := range q.currQueue { + q.currQueue[i] = FrameWriteRequest{} } - q.s = q.s[:0] + for i := range q.nextQueue { + q.nextQueue[i] = FrameWriteRequest{} + } + q.currQueue = q.currQueue[:0] + q.nextQueue = q.nextQueue[:0] + q.currPos = 0 *p = append(*p, q) } diff --git a/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go b/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go index 6d24d6a..4e33c29 100644 --- a/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go +++ b/vendor/golang.org/x/net/http2/writesched_priority_rfc7540.go @@ -214,8 +214,8 @@ func (z sortPriorityNodeSiblingsRFC7540) Swap(i, k int) { z[i], z[k] = z[k], z[i func (z sortPriorityNodeSiblingsRFC7540) Less(i, k int) bool { // Prefer the subtree that has sent fewer bytes relative to its weight. // See sections 5.3.2 and 5.3.4. - wi, bi := float64(z[i].weight+1), float64(z[i].subtreeBytes) - wk, bk := float64(z[k].weight+1), float64(z[k].subtreeBytes) + wi, bi := float64(z[i].weight)+1, float64(z[i].subtreeBytes) + wk, bk := float64(z[k].weight)+1, float64(z[k].subtreeBytes) if bi == 0 && bk == 0 { return wi >= wk } @@ -302,7 +302,6 @@ func (ws *priorityWriteSchedulerRFC7540) CloseStream(streamID uint32) { q := n.q ws.queuePool.put(&q) - n.q.s = nil if ws.maxClosedNodesInTree > 0 { ws.addClosedOrIdleNode(&ws.closedNodes, ws.maxClosedNodesInTree, n) } else { diff --git a/vendor/golang.org/x/net/http2/writesched_priority_rfc9128.go b/vendor/golang.org/x/net/http2/writesched_priority_rfc9218.go similarity index 99% rename from vendor/golang.org/x/net/http2/writesched_priority_rfc9128.go rename to vendor/golang.org/x/net/http2/writesched_priority_rfc9218.go index 9b5b880..cb4cadc 100644 --- a/vendor/golang.org/x/net/http2/writesched_priority_rfc9128.go +++ b/vendor/golang.org/x/net/http2/writesched_priority_rfc9218.go @@ -39,7 +39,7 @@ type priorityWriteSchedulerRFC9218 struct { prioritizeIncremental bool } -func newPriorityWriteSchedulerRFC9128() WriteScheduler { +func newPriorityWriteSchedulerRFC9218() WriteScheduler { ws := &priorityWriteSchedulerRFC9218{ streams: make(map[uint32]streamMetadata), } diff --git a/vendor/golang.org/x/net/publicsuffix/list.go b/vendor/golang.org/x/net/publicsuffix/list.go index 047cb30..7ab8b3c 100644 --- a/vendor/golang.org/x/net/publicsuffix/list.go +++ b/vendor/golang.org/x/net/publicsuffix/list.go @@ -51,6 +51,7 @@ package publicsuffix // import "golang.org/x/net/publicsuffix" import ( "fmt" "net/http/cookiejar" + "net/netip" "strings" ) @@ -84,6 +85,10 @@ func (list) String() string { // domains like "foo.appspot.com" can be found at // https://wiki.mozilla.org/Public_Suffix_List/Use_Cases func PublicSuffix(domain string) (publicSuffix string, icann bool) { + if _, err := netip.ParseAddr(domain); err == nil { + return domain, false + } + lo, hi := uint32(0), uint32(numTLD) s, suffix, icannNode, wildcard := domain, len(domain), false, false loop: diff --git a/vendor/golang.org/x/sys/cpu/cpu_arm64.s b/vendor/golang.org/x/sys/cpu/cpu_arm64.s index 22cc998..3b0450a 100644 --- a/vendor/golang.org/x/sys/cpu/cpu_arm64.s +++ b/vendor/golang.org/x/sys/cpu/cpu_arm64.s @@ -9,31 +9,27 @@ // func getisar0() uint64 TEXT ·getisar0(SB),NOSPLIT,$0-8 // get Instruction Set Attributes 0 into x0 - // mrs x0, ID_AA64ISAR0_EL1 = d5380600 - WORD $0xd5380600 + MRS ID_AA64ISAR0_EL1, R0 MOVD R0, ret+0(FP) RET // func getisar1() uint64 TEXT ·getisar1(SB),NOSPLIT,$0-8 // get Instruction Set Attributes 1 into x0 - // mrs x0, ID_AA64ISAR1_EL1 = d5380620 - WORD $0xd5380620 + MRS ID_AA64ISAR1_EL1, R0 MOVD R0, ret+0(FP) RET // func getpfr0() uint64 TEXT ·getpfr0(SB),NOSPLIT,$0-8 // get Processor Feature Register 0 into x0 - // mrs x0, ID_AA64PFR0_EL1 = d5380400 - WORD $0xd5380400 + MRS ID_AA64PFR0_EL1, R0 MOVD R0, ret+0(FP) RET // func getzfr0() uint64 TEXT ·getzfr0(SB),NOSPLIT,$0-8 // get SVE Feature Register 0 into x0 - // mrs x0, ID_AA64ZFR0_EL1 = d5380480 - WORD $0xd5380480 + MRS ID_AA64ZFR0_EL1, R0 MOVD R0, ret+0(FP) RET diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh index d1c8b26..fd39be4 100644 --- a/vendor/golang.org/x/sys/unix/mkerrors.sh +++ b/vendor/golang.org/x/sys/unix/mkerrors.sh @@ -226,6 +226,7 @@ struct ltchars { #include #include #include +#include #include #include #include @@ -255,6 +256,7 @@ struct ltchars { #include #include #include +#include #include #include #include @@ -529,6 +531,7 @@ ccflags="$@" $2 ~ /^O[CNPFPL][A-Z]+[^_][A-Z]+$/ || $2 ~ /^(NL|CR|TAB|BS|VT|FF)DLY$/ || $2 ~ /^(NL|CR|TAB|BS|VT|FF)[0-9]$/ || + $2 ~ /^(DT|EI|ELF|EV|NN|NT|PF|SHF|SHN|SHT|STB|STT|VER)_/ || $2 ~ /^O?XTABS$/ || $2 ~ /^TC[IO](ON|OFF)$/ || $2 ~ /^IN_/ || @@ -611,7 +614,7 @@ ccflags="$@" $2 !~ /IOC_MAGIC/ && $2 ~ /^[A-Z][A-Z0-9_]+_MAGIC2?$/ || $2 ~ /^(VM|VMADDR)_/ || - $2 ~ /^IOCTL_VM_SOCKETS_/ || + $2 ~ /^(IOCTL_VM_SOCKETS_|IOCTL_MEI_)/ || $2 ~ /^(TASKSTATS|TS)_/ || $2 ~ /^CGROUPSTATS_/ || $2 ~ /^GENL_/ || diff --git a/vendor/golang.org/x/sys/unix/syscall_linux.go b/vendor/golang.org/x/sys/unix/syscall_linux.go index 9439af9..06c0eea 100644 --- a/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -2643,3 +2643,9 @@ func SchedGetAttr(pid int, flags uint) (*SchedAttr, error) { //sys Cachestat(fd uint, crange *CachestatRange, cstat *Cachestat_t, flags uint) (err error) //sys Mseal(b []byte, flags uint) (err error) + +//sys setMemPolicy(mode int, mask *CPUSet, size int) (err error) = SYS_SET_MEMPOLICY + +func SetMemPolicy(mode int, mask *CPUSet) error { + return setMemPolicy(mode, mask, _CPU_SETSIZE) +} diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go index b6db27d..120a7b3 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -853,20 +853,86 @@ const ( DM_VERSION_MAJOR = 0x4 DM_VERSION_MINOR = 0x32 DM_VERSION_PATCHLEVEL = 0x0 + DT_ADDRRNGHI = 0x6ffffeff + DT_ADDRRNGLO = 0x6ffffe00 DT_BLK = 0x6 DT_CHR = 0x2 + DT_DEBUG = 0x15 DT_DIR = 0x4 + DT_ENCODING = 0x20 DT_FIFO = 0x1 + DT_FINI = 0xd + DT_FLAGS_1 = 0x6ffffffb + DT_GNU_HASH = 0x6ffffef5 + DT_HASH = 0x4 + DT_HIOS = 0x6ffff000 + DT_HIPROC = 0x7fffffff + DT_INIT = 0xc + DT_JMPREL = 0x17 DT_LNK = 0xa + DT_LOOS = 0x6000000d + DT_LOPROC = 0x70000000 + DT_NEEDED = 0x1 + DT_NULL = 0x0 + DT_PLTGOT = 0x3 + DT_PLTREL = 0x14 + DT_PLTRELSZ = 0x2 DT_REG = 0x8 + DT_REL = 0x11 + DT_RELA = 0x7 + DT_RELACOUNT = 0x6ffffff9 + DT_RELAENT = 0x9 + DT_RELASZ = 0x8 + DT_RELCOUNT = 0x6ffffffa + DT_RELENT = 0x13 + DT_RELSZ = 0x12 + DT_RPATH = 0xf DT_SOCK = 0xc + DT_SONAME = 0xe + DT_STRSZ = 0xa + DT_STRTAB = 0x5 + DT_SYMBOLIC = 0x10 + DT_SYMENT = 0xb + DT_SYMTAB = 0x6 + DT_TEXTREL = 0x16 DT_UNKNOWN = 0x0 + DT_VALRNGHI = 0x6ffffdff + DT_VALRNGLO = 0x6ffffd00 + DT_VERDEF = 0x6ffffffc + DT_VERDEFNUM = 0x6ffffffd + DT_VERNEED = 0x6ffffffe + DT_VERNEEDNUM = 0x6fffffff + DT_VERSYM = 0x6ffffff0 DT_WHT = 0xe ECHO = 0x8 ECRYPTFS_SUPER_MAGIC = 0xf15f EFD_SEMAPHORE = 0x1 EFIVARFS_MAGIC = 0xde5e81e4 EFS_SUPER_MAGIC = 0x414a53 + EI_CLASS = 0x4 + EI_DATA = 0x5 + EI_MAG0 = 0x0 + EI_MAG1 = 0x1 + EI_MAG2 = 0x2 + EI_MAG3 = 0x3 + EI_NIDENT = 0x10 + EI_OSABI = 0x7 + EI_PAD = 0x8 + EI_VERSION = 0x6 + ELFCLASS32 = 0x1 + ELFCLASS64 = 0x2 + ELFCLASSNONE = 0x0 + ELFCLASSNUM = 0x3 + ELFDATA2LSB = 0x1 + ELFDATA2MSB = 0x2 + ELFDATANONE = 0x0 + ELFMAG = "\177ELF" + ELFMAG0 = 0x7f + ELFMAG1 = 'E' + ELFMAG2 = 'L' + ELFMAG3 = 'F' + ELFOSABI_LINUX = 0x3 + ELFOSABI_NONE = 0x0 EM_386 = 0x3 EM_486 = 0x6 EM_68K = 0x4 @@ -1152,14 +1218,24 @@ const ( ETH_P_WCCP = 0x883e ETH_P_X25 = 0x805 ETH_P_XDSA = 0xf8 + ET_CORE = 0x4 + ET_DYN = 0x3 + ET_EXEC = 0x2 + ET_HIPROC = 0xffff + ET_LOPROC = 0xff00 + ET_NONE = 0x0 + ET_REL = 0x1 EV_ABS = 0x3 EV_CNT = 0x20 + EV_CURRENT = 0x1 EV_FF = 0x15 EV_FF_STATUS = 0x17 EV_KEY = 0x1 EV_LED = 0x11 EV_MAX = 0x1f EV_MSC = 0x4 + EV_NONE = 0x0 + EV_NUM = 0x2 EV_PWR = 0x16 EV_REL = 0x2 EV_REP = 0x14 @@ -1539,6 +1615,8 @@ const ( IN_OPEN = 0x20 IN_Q_OVERFLOW = 0x4000 IN_UNMOUNT = 0x2000 + IOCTL_MEI_CONNECT_CLIENT = 0xc0104801 + IOCTL_MEI_CONNECT_CLIENT_VTAG = 0xc0144804 IPPROTO_AH = 0x33 IPPROTO_BEETPH = 0x5e IPPROTO_COMP = 0x6c @@ -2276,7 +2354,167 @@ const ( NLM_F_REPLACE = 0x100 NLM_F_REQUEST = 0x1 NLM_F_ROOT = 0x100 + NN_386_IOPERM = "LINUX" + NN_386_TLS = "LINUX" + NN_ARC_V2 = "LINUX" + NN_ARM_FPMR = "LINUX" + NN_ARM_GCS = "LINUX" + NN_ARM_HW_BREAK = "LINUX" + NN_ARM_HW_WATCH = "LINUX" + NN_ARM_PACA_KEYS = "LINUX" + NN_ARM_PACG_KEYS = "LINUX" + NN_ARM_PAC_ENABLED_KEYS = "LINUX" + NN_ARM_PAC_MASK = "LINUX" + NN_ARM_POE = "LINUX" + NN_ARM_SSVE = "LINUX" + NN_ARM_SVE = "LINUX" + NN_ARM_SYSTEM_CALL = "LINUX" + NN_ARM_TAGGED_ADDR_CTRL = "LINUX" + NN_ARM_TLS = "LINUX" + NN_ARM_VFP = "LINUX" + NN_ARM_ZA = "LINUX" + NN_ARM_ZT = "LINUX" + NN_AUXV = "CORE" + NN_FILE = "CORE" + NN_GNU_PROPERTY_TYPE_0 = "GNU" + NN_LOONGARCH_CPUCFG = "LINUX" + NN_LOONGARCH_CSR = "LINUX" + NN_LOONGARCH_HW_BREAK = "LINUX" + NN_LOONGARCH_HW_WATCH = "LINUX" + NN_LOONGARCH_LASX = "LINUX" + NN_LOONGARCH_LBT = "LINUX" + NN_LOONGARCH_LSX = "LINUX" + NN_MIPS_DSP = "LINUX" + NN_MIPS_FP_MODE = "LINUX" + NN_MIPS_MSA = "LINUX" + NN_PPC_DEXCR = "LINUX" + NN_PPC_DSCR = "LINUX" + NN_PPC_EBB = "LINUX" + NN_PPC_HASHKEYR = "LINUX" + NN_PPC_PKEY = "LINUX" + NN_PPC_PMU = "LINUX" + NN_PPC_PPR = "LINUX" + NN_PPC_SPE = "LINUX" + NN_PPC_TAR = "LINUX" + NN_PPC_TM_CDSCR = "LINUX" + NN_PPC_TM_CFPR = "LINUX" + NN_PPC_TM_CGPR = "LINUX" + NN_PPC_TM_CPPR = "LINUX" + NN_PPC_TM_CTAR = "LINUX" + NN_PPC_TM_CVMX = "LINUX" + NN_PPC_TM_CVSX = "LINUX" + NN_PPC_TM_SPR = "LINUX" + NN_PPC_VMX = "LINUX" + NN_PPC_VSX = "LINUX" + NN_PRFPREG = "CORE" + NN_PRPSINFO = "CORE" + NN_PRSTATUS = "CORE" + NN_PRXFPREG = "LINUX" + NN_RISCV_CSR = "LINUX" + NN_RISCV_TAGGED_ADDR_CTRL = "LINUX" + NN_RISCV_VECTOR = "LINUX" + NN_S390_CTRS = "LINUX" + NN_S390_GS_BC = "LINUX" + NN_S390_GS_CB = "LINUX" + NN_S390_HIGH_GPRS = "LINUX" + NN_S390_LAST_BREAK = "LINUX" + NN_S390_PREFIX = "LINUX" + NN_S390_PV_CPU_DATA = "LINUX" + NN_S390_RI_CB = "LINUX" + NN_S390_SYSTEM_CALL = "LINUX" + NN_S390_TDB = "LINUX" + NN_S390_TIMER = "LINUX" + NN_S390_TODCMP = "LINUX" + NN_S390_TODPREG = "LINUX" + NN_S390_VXRS_HIGH = "LINUX" + NN_S390_VXRS_LOW = "LINUX" + NN_SIGINFO = "CORE" + NN_TASKSTRUCT = "CORE" + NN_VMCOREDD = "LINUX" + NN_X86_SHSTK = "LINUX" + NN_X86_XSAVE_LAYOUT = "LINUX" + NN_X86_XSTATE = "LINUX" NSFS_MAGIC = 0x6e736673 + NT_386_IOPERM = 0x201 + NT_386_TLS = 0x200 + NT_ARC_V2 = 0x600 + NT_ARM_FPMR = 0x40e + NT_ARM_GCS = 0x410 + NT_ARM_HW_BREAK = 0x402 + NT_ARM_HW_WATCH = 0x403 + NT_ARM_PACA_KEYS = 0x407 + NT_ARM_PACG_KEYS = 0x408 + NT_ARM_PAC_ENABLED_KEYS = 0x40a + NT_ARM_PAC_MASK = 0x406 + NT_ARM_POE = 0x40f + NT_ARM_SSVE = 0x40b + NT_ARM_SVE = 0x405 + NT_ARM_SYSTEM_CALL = 0x404 + NT_ARM_TAGGED_ADDR_CTRL = 0x409 + NT_ARM_TLS = 0x401 + NT_ARM_VFP = 0x400 + NT_ARM_ZA = 0x40c + NT_ARM_ZT = 0x40d + NT_AUXV = 0x6 + NT_FILE = 0x46494c45 + NT_GNU_PROPERTY_TYPE_0 = 0x5 + NT_LOONGARCH_CPUCFG = 0xa00 + NT_LOONGARCH_CSR = 0xa01 + NT_LOONGARCH_HW_BREAK = 0xa05 + NT_LOONGARCH_HW_WATCH = 0xa06 + NT_LOONGARCH_LASX = 0xa03 + NT_LOONGARCH_LBT = 0xa04 + NT_LOONGARCH_LSX = 0xa02 + NT_MIPS_DSP = 0x800 + NT_MIPS_FP_MODE = 0x801 + NT_MIPS_MSA = 0x802 + NT_PPC_DEXCR = 0x111 + NT_PPC_DSCR = 0x105 + NT_PPC_EBB = 0x106 + NT_PPC_HASHKEYR = 0x112 + NT_PPC_PKEY = 0x110 + NT_PPC_PMU = 0x107 + NT_PPC_PPR = 0x104 + NT_PPC_SPE = 0x101 + NT_PPC_TAR = 0x103 + NT_PPC_TM_CDSCR = 0x10f + NT_PPC_TM_CFPR = 0x109 + NT_PPC_TM_CGPR = 0x108 + NT_PPC_TM_CPPR = 0x10e + NT_PPC_TM_CTAR = 0x10d + NT_PPC_TM_CVMX = 0x10a + NT_PPC_TM_CVSX = 0x10b + NT_PPC_TM_SPR = 0x10c + NT_PPC_VMX = 0x100 + NT_PPC_VSX = 0x102 + NT_PRFPREG = 0x2 + NT_PRPSINFO = 0x3 + NT_PRSTATUS = 0x1 + NT_PRXFPREG = 0x46e62b7f + NT_RISCV_CSR = 0x900 + NT_RISCV_TAGGED_ADDR_CTRL = 0x902 + NT_RISCV_VECTOR = 0x901 + NT_S390_CTRS = 0x304 + NT_S390_GS_BC = 0x30c + NT_S390_GS_CB = 0x30b + NT_S390_HIGH_GPRS = 0x300 + NT_S390_LAST_BREAK = 0x306 + NT_S390_PREFIX = 0x305 + NT_S390_PV_CPU_DATA = 0x30e + NT_S390_RI_CB = 0x30d + NT_S390_SYSTEM_CALL = 0x307 + NT_S390_TDB = 0x308 + NT_S390_TIMER = 0x301 + NT_S390_TODCMP = 0x302 + NT_S390_TODPREG = 0x303 + NT_S390_VXRS_HIGH = 0x30a + NT_S390_VXRS_LOW = 0x309 + NT_SIGINFO = 0x53494749 + NT_TASKSTRUCT = 0x4 + NT_VMCOREDD = 0x700 + NT_X86_SHSTK = 0x204 + NT_X86_XSAVE_LAYOUT = 0x205 + NT_X86_XSTATE = 0x202 OCFS2_SUPER_MAGIC = 0x7461636f OCRNL = 0x8 OFDEL = 0x80 @@ -2463,6 +2701,59 @@ const ( PERF_RECORD_MISC_USER = 0x2 PERF_SAMPLE_BRANCH_PLM_ALL = 0x7 PERF_SAMPLE_WEIGHT_TYPE = 0x1004000 + PF_ALG = 0x26 + PF_APPLETALK = 0x5 + PF_ASH = 0x12 + PF_ATMPVC = 0x8 + PF_ATMSVC = 0x14 + PF_AX25 = 0x3 + PF_BLUETOOTH = 0x1f + PF_BRIDGE = 0x7 + PF_CAIF = 0x25 + PF_CAN = 0x1d + PF_DECnet = 0xc + PF_ECONET = 0x13 + PF_FILE = 0x1 + PF_IB = 0x1b + PF_IEEE802154 = 0x24 + PF_INET = 0x2 + PF_INET6 = 0xa + PF_IPX = 0x4 + PF_IRDA = 0x17 + PF_ISDN = 0x22 + PF_IUCV = 0x20 + PF_KCM = 0x29 + PF_KEY = 0xf + PF_LLC = 0x1a + PF_LOCAL = 0x1 + PF_MAX = 0x2e + PF_MCTP = 0x2d + PF_MPLS = 0x1c + PF_NETBEUI = 0xd + PF_NETLINK = 0x10 + PF_NETROM = 0x6 + PF_NFC = 0x27 + PF_PACKET = 0x11 + PF_PHONET = 0x23 + PF_PPPOX = 0x18 + PF_QIPCRTR = 0x2a + PF_R = 0x4 + PF_RDS = 0x15 + PF_ROSE = 0xb + PF_ROUTE = 0x10 + PF_RXRPC = 0x21 + PF_SECURITY = 0xe + PF_SMC = 0x2b + PF_SNA = 0x16 + PF_TIPC = 0x1e + PF_UNIX = 0x1 + PF_UNSPEC = 0x0 + PF_VSOCK = 0x28 + PF_W = 0x2 + PF_WANPIPE = 0x19 + PF_X = 0x1 + PF_X25 = 0x9 + PF_XDP = 0x2c PID_FS_MAGIC = 0x50494446 PIPEFS_MAGIC = 0x50495045 PPPIOCGNPMODE = 0xc008744c @@ -2758,6 +3049,23 @@ const ( PTRACE_SYSCALL_INFO_NONE = 0x0 PTRACE_SYSCALL_INFO_SECCOMP = 0x3 PTRACE_TRACEME = 0x0 + PT_AARCH64_MEMTAG_MTE = 0x70000002 + PT_DYNAMIC = 0x2 + PT_GNU_EH_FRAME = 0x6474e550 + PT_GNU_PROPERTY = 0x6474e553 + PT_GNU_RELRO = 0x6474e552 + PT_GNU_STACK = 0x6474e551 + PT_HIOS = 0x6fffffff + PT_HIPROC = 0x7fffffff + PT_INTERP = 0x3 + PT_LOAD = 0x1 + PT_LOOS = 0x60000000 + PT_LOPROC = 0x70000000 + PT_NOTE = 0x4 + PT_NULL = 0x0 + PT_PHDR = 0x6 + PT_SHLIB = 0x5 + PT_TLS = 0x7 P_ALL = 0x0 P_PGID = 0x2 P_PID = 0x1 @@ -3091,6 +3399,47 @@ const ( SEEK_MAX = 0x4 SEEK_SET = 0x0 SELINUX_MAGIC = 0xf97cff8c + SHF_ALLOC = 0x2 + SHF_EXCLUDE = 0x8000000 + SHF_EXECINSTR = 0x4 + SHF_GROUP = 0x200 + SHF_INFO_LINK = 0x40 + SHF_LINK_ORDER = 0x80 + SHF_MASKOS = 0xff00000 + SHF_MASKPROC = 0xf0000000 + SHF_MERGE = 0x10 + SHF_ORDERED = 0x4000000 + SHF_OS_NONCONFORMING = 0x100 + SHF_RELA_LIVEPATCH = 0x100000 + SHF_RO_AFTER_INIT = 0x200000 + SHF_STRINGS = 0x20 + SHF_TLS = 0x400 + SHF_WRITE = 0x1 + SHN_ABS = 0xfff1 + SHN_COMMON = 0xfff2 + SHN_HIPROC = 0xff1f + SHN_HIRESERVE = 0xffff + SHN_LIVEPATCH = 0xff20 + SHN_LOPROC = 0xff00 + SHN_LORESERVE = 0xff00 + SHN_UNDEF = 0x0 + SHT_DYNAMIC = 0x6 + SHT_DYNSYM = 0xb + SHT_HASH = 0x5 + SHT_HIPROC = 0x7fffffff + SHT_HIUSER = 0xffffffff + SHT_LOPROC = 0x70000000 + SHT_LOUSER = 0x80000000 + SHT_NOBITS = 0x8 + SHT_NOTE = 0x7 + SHT_NULL = 0x0 + SHT_NUM = 0xc + SHT_PROGBITS = 0x1 + SHT_REL = 0x9 + SHT_RELA = 0x4 + SHT_SHLIB = 0xa + SHT_STRTAB = 0x3 + SHT_SYMTAB = 0x2 SHUT_RD = 0x0 SHUT_RDWR = 0x2 SHUT_WR = 0x1 @@ -3317,6 +3666,16 @@ const ( STATX_UID = 0x8 STATX_WRITE_ATOMIC = 0x10000 STATX__RESERVED = 0x80000000 + STB_GLOBAL = 0x1 + STB_LOCAL = 0x0 + STB_WEAK = 0x2 + STT_COMMON = 0x5 + STT_FILE = 0x4 + STT_FUNC = 0x2 + STT_NOTYPE = 0x0 + STT_OBJECT = 0x1 + STT_SECTION = 0x3 + STT_TLS = 0x6 SYNC_FILE_RANGE_WAIT_AFTER = 0x4 SYNC_FILE_RANGE_WAIT_BEFORE = 0x1 SYNC_FILE_RANGE_WRITE = 0x2 @@ -3553,6 +3912,8 @@ const ( UTIME_OMIT = 0x3ffffffe V9FS_MAGIC = 0x1021997 VERASE = 0x2 + VER_FLG_BASE = 0x1 + VER_FLG_WEAK = 0x2 VINTR = 0x0 VKILL = 0x3 VLNEXT = 0xf diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go index 1c37f9f..97a61fc 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go @@ -116,6 +116,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go index 6f54d34..a0d6d49 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go @@ -116,6 +116,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go index 783ec5c..dd9c903 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go index ca83d3b..384c61c 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go @@ -120,6 +120,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go index 607e611..6384c98 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go @@ -116,6 +116,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go index b9cb5bd..553c1c6 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x100 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x80 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go index 65b078a..b3339f2 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x100 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x80 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go index 5298a30..177091d 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x100 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x80 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go index 7bc557c..c5abf15 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x100 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x80 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go index 152399b..f1f3fad 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x400 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go index 1a1ce24..203ad9c 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x400 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go index 4231a1f..4b9abcb 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x400 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go index 21c0e95..f879830 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xffffff0f IPV6_FLOWLABEL_MASK = 0xffff0f00 diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go index f00d1cd..64347eb 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go @@ -115,6 +115,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x80000 IN_NONBLOCK = 0x800 + IOCTL_MEI_NOTIFY_GET = 0x80044803 + IOCTL_MEI_NOTIFY_SET = 0x40044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x7b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go index bc8d539..7d71911 100644 --- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go +++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go @@ -119,6 +119,8 @@ const ( IEXTEN = 0x8000 IN_CLOEXEC = 0x400000 IN_NONBLOCK = 0x4000 + IOCTL_MEI_NOTIFY_GET = 0x40044803 + IOCTL_MEI_NOTIFY_SET = 0x80044802 IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9 IPV6_FLOWINFO_MASK = 0xfffffff IPV6_FLOWLABEL_MASK = 0xfffff diff --git a/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/vendor/golang.org/x/sys/unix/zsyscall_linux.go index 5cc1e8e..8935d10 100644 --- a/vendor/golang.org/x/sys/unix/zsyscall_linux.go +++ b/vendor/golang.org/x/sys/unix/zsyscall_linux.go @@ -2238,3 +2238,13 @@ func Mseal(b []byte, flags uint) (err error) { } return } + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + +func setMemPolicy(mode int, mask *CPUSet, size int) (err error) { + _, _, e1 := Syscall(SYS_SET_MEMPOLICY, uintptr(mode), uintptr(unsafe.Pointer(mask)), uintptr(size)) + if e1 != 0 { + err = errnoErr(e1) + } + return +} diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go index 944e75a..c1a4670 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -3590,6 +3590,8 @@ type Nhmsg struct { Flags uint32 } +const SizeofNhmsg = 0x8 + type NexthopGrp struct { Id uint32 Weight uint8 @@ -3597,6 +3599,8 @@ type NexthopGrp struct { Resvd2 uint16 } +const SizeofNexthopGrp = 0x8 + const ( NHA_UNSPEC = 0x0 NHA_ID = 0x1 @@ -6332,3 +6336,30 @@ type SockDiagReq struct { } const RTM_NEWNVLAN = 0x70 + +const ( + MPOL_BIND = 0x2 + MPOL_DEFAULT = 0x0 + MPOL_F_ADDR = 0x2 + MPOL_F_MEMS_ALLOWED = 0x4 + MPOL_F_MOF = 0x8 + MPOL_F_MORON = 0x10 + MPOL_F_NODE = 0x1 + MPOL_F_NUMA_BALANCING = 0x2000 + MPOL_F_RELATIVE_NODES = 0x4000 + MPOL_F_SHARED = 0x1 + MPOL_F_STATIC_NODES = 0x8000 + MPOL_INTERLEAVE = 0x3 + MPOL_LOCAL = 0x4 + MPOL_MAX = 0x7 + MPOL_MF_INTERNAL = 0x10 + MPOL_MF_LAZY = 0x8 + MPOL_MF_MOVE_ALL = 0x4 + MPOL_MF_MOVE = 0x2 + MPOL_MF_STRICT = 0x1 + MPOL_MF_VALID = 0x7 + MPOL_MODE_FLAGS = 0xe000 + MPOL_PREFERRED = 0x1 + MPOL_PREFERRED_MANY = 0x5 + MPOL_WEIGHTED_INTERLEAVE = 0x6 +) diff --git a/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go b/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go index 439548e..50e8e64 100644 --- a/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go +++ b/vendor/golang.org/x/sys/unix/ztypes_netbsd_arm.go @@ -104,7 +104,7 @@ type Statvfs_t struct { Fsid uint32 Namemax uint32 Owner uint32 - Spare [4]uint32 + Spare [4]uint64 Fstypename [32]byte Mntonname [1024]byte Mntfromname [1024]byte diff --git a/vendor/golang.org/x/sys/windows/syscall_windows.go b/vendor/golang.org/x/sys/windows/syscall_windows.go index bd51337..69439df 100644 --- a/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -892,8 +892,12 @@ const socket_error = uintptr(^uint32(0)) //sys MultiByteToWideChar(codePage uint32, dwFlags uint32, str *byte, nstr int32, wchar *uint16, nwchar int32) (nwrite int32, err error) = kernel32.MultiByteToWideChar //sys getBestInterfaceEx(sockaddr unsafe.Pointer, pdwBestIfIndex *uint32) (errcode error) = iphlpapi.GetBestInterfaceEx //sys GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) = iphlpapi.GetIfEntry2Ex +//sys GetIpForwardEntry2(row *MibIpForwardRow2) (errcode error) = iphlpapi.GetIpForwardEntry2 +//sys GetIpForwardTable2(family uint16, table **MibIpForwardTable2) (errcode error) = iphlpapi.GetIpForwardTable2 //sys GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) = iphlpapi.GetUnicastIpAddressEntry +//sys FreeMibTable(memory unsafe.Pointer) = iphlpapi.FreeMibTable //sys NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyIpInterfaceChange +//sys NotifyRouteChange2(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyRouteChange2 //sys NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) = iphlpapi.NotifyUnicastIpAddressChange //sys CancelMibChangeNotify2(notificationHandle Handle) (errcode error) = iphlpapi.CancelMibChangeNotify2 @@ -916,6 +920,17 @@ type RawSockaddrInet6 struct { Scope_id uint32 } +// RawSockaddrInet is a union that contains an IPv4, an IPv6 address, or an address family. See +// https://learn.microsoft.com/en-us/windows/win32/api/ws2ipdef/ns-ws2ipdef-sockaddr_inet. +// +// A [*RawSockaddrInet] may be converted to a [*RawSockaddrInet4] or [*RawSockaddrInet6] using +// unsafe, depending on the address family. +type RawSockaddrInet struct { + Family uint16 + Port uint16 + Data [6]uint32 +} + type RawSockaddr struct { Family uint16 Data [14]int8 diff --git a/vendor/golang.org/x/sys/windows/types_windows.go b/vendor/golang.org/x/sys/windows/types_windows.go index 358be3c..6e4f50e 100644 --- a/vendor/golang.org/x/sys/windows/types_windows.go +++ b/vendor/golang.org/x/sys/windows/types_windows.go @@ -2320,6 +2320,82 @@ type MibIfRow2 struct { OutQLen uint64 } +// IP_ADDRESS_PREFIX stores an IP address prefix. See +// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-ip_address_prefix. +type IpAddressPrefix struct { + Prefix RawSockaddrInet + PrefixLength uint8 +} + +// NL_ROUTE_ORIGIN enumeration from nldef.h or +// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_route_origin. +const ( + NlroManual = 0 + NlroWellKnown = 1 + NlroDHCP = 2 + NlroRouterAdvertisement = 3 + Nlro6to4 = 4 +) + +// NL_ROUTE_ORIGIN enumeration from nldef.h or +// https://learn.microsoft.com/en-us/windows/win32/api/nldef/ne-nldef-nl_route_protocol. +const ( + MIB_IPPROTO_OTHER = 1 + MIB_IPPROTO_LOCAL = 2 + MIB_IPPROTO_NETMGMT = 3 + MIB_IPPROTO_ICMP = 4 + MIB_IPPROTO_EGP = 5 + MIB_IPPROTO_GGP = 6 + MIB_IPPROTO_HELLO = 7 + MIB_IPPROTO_RIP = 8 + MIB_IPPROTO_IS_IS = 9 + MIB_IPPROTO_ES_IS = 10 + MIB_IPPROTO_CISCO = 11 + MIB_IPPROTO_BBN = 12 + MIB_IPPROTO_OSPF = 13 + MIB_IPPROTO_BGP = 14 + MIB_IPPROTO_IDPR = 15 + MIB_IPPROTO_EIGRP = 16 + MIB_IPPROTO_DVMRP = 17 + MIB_IPPROTO_RPL = 18 + MIB_IPPROTO_DHCP = 19 + MIB_IPPROTO_NT_AUTOSTATIC = 10002 + MIB_IPPROTO_NT_STATIC = 10006 + MIB_IPPROTO_NT_STATIC_NON_DOD = 10007 +) + +// MIB_IPFORWARD_ROW2 stores information about an IP route entry. See +// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipforward_row2. +type MibIpForwardRow2 struct { + InterfaceLuid uint64 + InterfaceIndex uint32 + DestinationPrefix IpAddressPrefix + NextHop RawSockaddrInet + SitePrefixLength uint8 + ValidLifetime uint32 + PreferredLifetime uint32 + Metric uint32 + Protocol uint32 + Loopback uint8 + AutoconfigureAddress uint8 + Publish uint8 + Immortal uint8 + Age uint32 + Origin uint32 +} + +// MIB_IPFORWARD_TABLE2 contains a table of IP route entries. See +// https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_ipforward_table2. +type MibIpForwardTable2 struct { + NumEntries uint32 + Table [1]MibIpForwardRow2 +} + +// Rows returns the IP route entries in the table. +func (t *MibIpForwardTable2) Rows() []MibIpForwardRow2 { + return unsafe.Slice(&t.Table[0], t.NumEntries) +} + // MIB_UNICASTIPADDRESS_ROW stores information about a unicast IP address. See // https://learn.microsoft.com/en-us/windows/win32/api/netioapi/ns-netioapi-mib_unicastipaddress_row. type MibUnicastIpAddressRow struct { diff --git a/vendor/golang.org/x/sys/windows/zsyscall_windows.go b/vendor/golang.org/x/sys/windows/zsyscall_windows.go index 426151a..f25b730 100644 --- a/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -182,13 +182,17 @@ var ( procDwmGetWindowAttribute = moddwmapi.NewProc("DwmGetWindowAttribute") procDwmSetWindowAttribute = moddwmapi.NewProc("DwmSetWindowAttribute") procCancelMibChangeNotify2 = modiphlpapi.NewProc("CancelMibChangeNotify2") + procFreeMibTable = modiphlpapi.NewProc("FreeMibTable") procGetAdaptersAddresses = modiphlpapi.NewProc("GetAdaptersAddresses") procGetAdaptersInfo = modiphlpapi.NewProc("GetAdaptersInfo") procGetBestInterfaceEx = modiphlpapi.NewProc("GetBestInterfaceEx") procGetIfEntry = modiphlpapi.NewProc("GetIfEntry") procGetIfEntry2Ex = modiphlpapi.NewProc("GetIfEntry2Ex") + procGetIpForwardEntry2 = modiphlpapi.NewProc("GetIpForwardEntry2") + procGetIpForwardTable2 = modiphlpapi.NewProc("GetIpForwardTable2") procGetUnicastIpAddressEntry = modiphlpapi.NewProc("GetUnicastIpAddressEntry") procNotifyIpInterfaceChange = modiphlpapi.NewProc("NotifyIpInterfaceChange") + procNotifyRouteChange2 = modiphlpapi.NewProc("NotifyRouteChange2") procNotifyUnicastIpAddressChange = modiphlpapi.NewProc("NotifyUnicastIpAddressChange") procAddDllDirectory = modkernel32.NewProc("AddDllDirectory") procAssignProcessToJobObject = modkernel32.NewProc("AssignProcessToJobObject") @@ -1624,6 +1628,11 @@ func CancelMibChangeNotify2(notificationHandle Handle) (errcode error) { return } +func FreeMibTable(memory unsafe.Pointer) { + syscall.SyscallN(procFreeMibTable.Addr(), uintptr(memory)) + return +} + func GetAdaptersAddresses(family uint32, flags uint32, reserved uintptr, adapterAddresses *IpAdapterAddresses, sizePointer *uint32) (errcode error) { r0, _, _ := syscall.SyscallN(procGetAdaptersAddresses.Addr(), uintptr(family), uintptr(flags), uintptr(reserved), uintptr(unsafe.Pointer(adapterAddresses)), uintptr(unsafe.Pointer(sizePointer))) if r0 != 0 { @@ -1664,6 +1673,22 @@ func GetIfEntry2Ex(level uint32, row *MibIfRow2) (errcode error) { return } +func GetIpForwardEntry2(row *MibIpForwardRow2) (errcode error) { + r0, _, _ := syscall.SyscallN(procGetIpForwardEntry2.Addr(), uintptr(unsafe.Pointer(row))) + if r0 != 0 { + errcode = syscall.Errno(r0) + } + return +} + +func GetIpForwardTable2(family uint16, table **MibIpForwardTable2) (errcode error) { + r0, _, _ := syscall.SyscallN(procGetIpForwardTable2.Addr(), uintptr(family), uintptr(unsafe.Pointer(table))) + if r0 != 0 { + errcode = syscall.Errno(r0) + } + return +} + func GetUnicastIpAddressEntry(row *MibUnicastIpAddressRow) (errcode error) { r0, _, _ := syscall.SyscallN(procGetUnicastIpAddressEntry.Addr(), uintptr(unsafe.Pointer(row))) if r0 != 0 { @@ -1684,6 +1709,18 @@ func NotifyIpInterfaceChange(family uint16, callback uintptr, callerContext unsa return } +func NotifyRouteChange2(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { + var _p0 uint32 + if initialNotification { + _p0 = 1 + } + r0, _, _ := syscall.SyscallN(procNotifyRouteChange2.Addr(), uintptr(family), uintptr(callback), uintptr(callerContext), uintptr(_p0), uintptr(unsafe.Pointer(notificationHandle))) + if r0 != 0 { + errcode = syscall.Errno(r0) + } + return +} + func NotifyUnicastIpAddressChange(family uint16, callback uintptr, callerContext unsafe.Pointer, initialNotification bool, notificationHandle *Handle) (errcode error) { var _p0 uint32 if initialNotification { diff --git a/vendor/golang.org/x/text/encoding/japanese/eucjp.go b/vendor/golang.org/x/text/encoding/japanese/eucjp.go index 79313fa..6fce8c5 100644 --- a/vendor/golang.org/x/text/encoding/japanese/eucjp.go +++ b/vendor/golang.org/x/text/encoding/japanese/eucjp.go @@ -17,9 +17,9 @@ import ( var EUCJP encoding.Encoding = &eucJP var eucJP = internal.Encoding{ - &internal.SimpleEncoding{eucJPDecoder{}, eucJPEncoder{}}, - "EUC-JP", - identifier.EUCPkdFmtJapanese, + Encoding: &internal.SimpleEncoding{Decoder: eucJPDecoder{}, Encoder: eucJPEncoder{}}, + Name: "EUC-JP", + MIB: identifier.EUCPkdFmtJapanese, } type eucJPDecoder struct{ transform.NopResetter } diff --git a/vendor/golang.org/x/text/encoding/japanese/iso2022jp.go b/vendor/golang.org/x/text/encoding/japanese/iso2022jp.go index 613226d..6f7bd46 100644 --- a/vendor/golang.org/x/text/encoding/japanese/iso2022jp.go +++ b/vendor/golang.org/x/text/encoding/japanese/iso2022jp.go @@ -17,9 +17,9 @@ import ( var ISO2022JP encoding.Encoding = &iso2022JP var iso2022JP = internal.Encoding{ - internal.FuncEncoding{iso2022JPNewDecoder, iso2022JPNewEncoder}, - "ISO-2022-JP", - identifier.ISO2022JP, + Encoding: internal.FuncEncoding{Decoder: iso2022JPNewDecoder, Encoder: iso2022JPNewEncoder}, + Name: "ISO-2022-JP", + MIB: identifier.ISO2022JP, } func iso2022JPNewDecoder() transform.Transformer { diff --git a/vendor/golang.org/x/text/encoding/japanese/shiftjis.go b/vendor/golang.org/x/text/encoding/japanese/shiftjis.go index 16fd8a6..af65d43 100644 --- a/vendor/golang.org/x/text/encoding/japanese/shiftjis.go +++ b/vendor/golang.org/x/text/encoding/japanese/shiftjis.go @@ -18,9 +18,9 @@ import ( var ShiftJIS encoding.Encoding = &shiftJIS var shiftJIS = internal.Encoding{ - &internal.SimpleEncoding{shiftJISDecoder{}, shiftJISEncoder{}}, - "Shift JIS", - identifier.ShiftJIS, + Encoding: &internal.SimpleEncoding{Decoder: shiftJISDecoder{}, Encoder: shiftJISEncoder{}}, + Name: "Shift JIS", + MIB: identifier.ShiftJIS, } type shiftJISDecoder struct{ transform.NopResetter } diff --git a/vendor/golang.org/x/text/encoding/korean/euckr.go b/vendor/golang.org/x/text/encoding/korean/euckr.go index 034337f..81c8347 100644 --- a/vendor/golang.org/x/text/encoding/korean/euckr.go +++ b/vendor/golang.org/x/text/encoding/korean/euckr.go @@ -20,9 +20,9 @@ var All = []encoding.Encoding{EUCKR} var EUCKR encoding.Encoding = &eucKR var eucKR = internal.Encoding{ - &internal.SimpleEncoding{eucKRDecoder{}, eucKREncoder{}}, - "EUC-KR", - identifier.EUCKR, + Encoding: &internal.SimpleEncoding{Decoder: eucKRDecoder{}, Encoder: eucKREncoder{}}, + Name: "EUC-KR", + MIB: identifier.EUCKR, } type eucKRDecoder struct{ transform.NopResetter } diff --git a/vendor/golang.org/x/text/encoding/simplifiedchinese/gbk.go b/vendor/golang.org/x/text/encoding/simplifiedchinese/gbk.go index 0e0fabf..2f2fd5d 100644 --- a/vendor/golang.org/x/text/encoding/simplifiedchinese/gbk.go +++ b/vendor/golang.org/x/text/encoding/simplifiedchinese/gbk.go @@ -22,21 +22,21 @@ var ( ) var gbk = internal.Encoding{ - &internal.SimpleEncoding{ - gbkDecoder{gb18030: false}, - gbkEncoder{gb18030: false}, + Encoding: &internal.SimpleEncoding{ + Decoder: gbkDecoder{gb18030: false}, + Encoder: gbkEncoder{gb18030: false}, }, - "GBK", - identifier.GBK, + Name: "GBK", + MIB: identifier.GBK, } var gbk18030 = internal.Encoding{ - &internal.SimpleEncoding{ - gbkDecoder{gb18030: true}, - gbkEncoder{gb18030: true}, + Encoding: &internal.SimpleEncoding{ + Decoder: gbkDecoder{gb18030: true}, + Encoder: gbkEncoder{gb18030: true}, }, - "GB18030", - identifier.GB18030, + Name: "GB18030", + MIB: identifier.GB18030, } type gbkDecoder struct { diff --git a/vendor/golang.org/x/text/encoding/simplifiedchinese/hzgb2312.go b/vendor/golang.org/x/text/encoding/simplifiedchinese/hzgb2312.go index e15b7bf..351750e 100644 --- a/vendor/golang.org/x/text/encoding/simplifiedchinese/hzgb2312.go +++ b/vendor/golang.org/x/text/encoding/simplifiedchinese/hzgb2312.go @@ -17,9 +17,9 @@ import ( var HZGB2312 encoding.Encoding = &hzGB2312 var hzGB2312 = internal.Encoding{ - internal.FuncEncoding{hzGB2312NewDecoder, hzGB2312NewEncoder}, - "HZ-GB2312", - identifier.HZGB2312, + Encoding: internal.FuncEncoding{Decoder: hzGB2312NewDecoder, Encoder: hzGB2312NewEncoder}, + Name: "HZ-GB2312", + MIB: identifier.HZGB2312, } func hzGB2312NewDecoder() transform.Transformer { diff --git a/vendor/golang.org/x/text/encoding/traditionalchinese/big5.go b/vendor/golang.org/x/text/encoding/traditionalchinese/big5.go index 1fcddde..5046920 100644 --- a/vendor/golang.org/x/text/encoding/traditionalchinese/big5.go +++ b/vendor/golang.org/x/text/encoding/traditionalchinese/big5.go @@ -20,9 +20,9 @@ var All = []encoding.Encoding{Big5} var Big5 encoding.Encoding = &big5 var big5 = internal.Encoding{ - &internal.SimpleEncoding{big5Decoder{}, big5Encoder{}}, - "Big5", - identifier.Big5, + Encoding: &internal.SimpleEncoding{Decoder: big5Decoder{}, Encoder: big5Encoder{}}, + Name: "Big5", + MIB: identifier.Big5, } type big5Decoder struct{ transform.NopResetter } diff --git a/vendor/golang.org/x/text/encoding/unicode/unicode.go b/vendor/golang.org/x/text/encoding/unicode/unicode.go index dd99ad1..ce28c90 100644 --- a/vendor/golang.org/x/text/encoding/unicode/unicode.go +++ b/vendor/golang.org/x/text/encoding/unicode/unicode.go @@ -60,9 +60,9 @@ func (utf8bomEncoding) NewDecoder() *encoding.Decoder { } var utf8enc = &internal.Encoding{ - &internal.SimpleEncoding{utf8Decoder{}, runes.ReplaceIllFormed()}, - "UTF-8", - identifier.UTF8, + Encoding: &internal.SimpleEncoding{Decoder: utf8Decoder{}, Encoder: runes.ReplaceIllFormed()}, + Name: "UTF-8", + MIB: identifier.UTF8, } type utf8bomDecoder struct { diff --git a/vendor/maunium.net/go/mautrix/CHANGELOG.md b/vendor/maunium.net/go/mautrix/CHANGELOG.md index f59e685..b6c0ff7 100644 --- a/vendor/maunium.net/go/mautrix/CHANGELOG.md +++ b/vendor/maunium.net/go/mautrix/CHANGELOG.md @@ -1,3 +1,53 @@ +## v0.26.0 (2025-11-16) + +* *(client,appservice)* Deprecated `SendMassagedStateEvent` as `SendStateEvent` + has been able to do the same for a while now. +* *(client,federation)* Added size limits for responses to make it safer to send + requests to untrusted servers. +* *(client)* Added wrapper for `/admin/whois` client API + (thanks to [@nexy7574] in [#411]). +* *(synapseadmin)* Added `force_purge` option to DeleteRoom + (thanks to [@nexy7574] in [#420]). +* *(statestore)* Added saving join rules for rooms. +* *(bridgev2)* Added optional automatic rollback of room state if bridging the + change to the remote network fails. +* *(bridgev2)* Added management room notices if transient disconnect state + doesn't resolve within 3 minutes. +* *(bridgev2)* Added interface to signal that certain participants couldn't be + invited when creating a group. +* *(bridgev2)* Added `select` type for user input fields in login. +* *(bridgev2)* Added interface to let network connector customize personal + filtering space. +* *(bridgev2/matrix)* Added checks to avoid sending error messages in reply to + other bots. +* *(bridgev2/matrix)* Switched to using [MSC4169] to send redactions whenever + possible. +* *(bridgev2/publicmedia)* Added support for custom path prefixes, file names, + and encrypted files. +* *(bridgev2/commands)* Added command to resync a single portal. +* *(bridgev2/commands)* Added create group command. +* *(bridgev2/config)* Added option to limit maximum number of logins. +* *(bridgev2)* Changed ghost joining to skip unnecessary invite if portal room + is public. +* *(bridgev2/disappear)* Changed read receipt handling to only start + disappearing timers for messages up to the read message (note: may not work in + all cases if the read receipt points at an unknown event). +* *(event/reply)* Changed plaintext reply fallback removal to only happen when + an HTML reply fallback is removed successfully. +* *(bridgev2/matrix)* Fixed unnecessary sleep after registering bot on first run. +* *(crypto/goolm)* Fixed panic when processing certain malformed Olm messages. +* *(federation)* Fixed HTTP method for sending transactions + (thanks to [@nexy7574] in [#426]). +* *(federation)* Fixed response body being closed even when using `DontReadBody` + parameter. +* *(federation)* Fixed validating auth for requests with query params. +* *(federation/eventauth)* Fixed typo causing restricted joins to not work. + +[MSC416]: https://github.com/matrix-org/matrix-spec-proposals/pull/4169 +[#411]: github.com/mautrix/go/pull/411 +[#420]: github.com/mautrix/go/pull/420 +[#426]: github.com/mautrix/go/pull/426 + ## v0.25.2 (2025-10-16) * **Breaking change *(id)*** Split `UserID.ParseAndValidate` into diff --git a/vendor/maunium.net/go/mautrix/client.go b/vendor/maunium.net/go/mautrix/client.go index 95cbacb..d07bede 100644 --- a/vendor/maunium.net/go/mautrix/client.go +++ b/vendor/maunium.net/go/mautrix/client.go @@ -111,6 +111,8 @@ type Client struct { // Set to true to disable automatically sleeping on 429 errors. IgnoreRateLimit bool + ResponseSizeLimit int64 + txnID int32 // Should the ?user_id= query parameter be set in requests? @@ -143,6 +145,8 @@ func DiscoverClientAPI(ctx context.Context, serverName string) (*ClientWellKnown return DiscoverClientAPIWithClient(ctx, &http.Client{Timeout: 30 * time.Second}, serverName) } +const WellKnownMaxSize = 64 * 1024 + func DiscoverClientAPIWithClient(ctx context.Context, client *http.Client, serverName string) (*ClientWellKnown, error) { wellKnownURL := url.URL{ Scheme: "https", @@ -168,11 +172,15 @@ func DiscoverClientAPIWithClient(ctx context.Context, client *http.Client, serve if resp.StatusCode == http.StatusNotFound { return nil, nil + } else if resp.ContentLength > WellKnownMaxSize { + return nil, errors.New(".well-known response too large") } - data, err := io.ReadAll(resp.Body) + data, err := io.ReadAll(io.LimitReader(resp.Body, WellKnownMaxSize)) if err != nil { return nil, err + } else if len(data) >= WellKnownMaxSize { + return nil, errors.New(".well-known response too large") } var wellKnown ClientWellKnown @@ -395,24 +403,25 @@ func (cli *Client) MakeRequest(ctx context.Context, method string, httpURL strin return cli.MakeFullRequest(ctx, FullRequest{Method: method, URL: httpURL, RequestJSON: reqBody, ResponseJSON: resBody}) } -type ClientResponseHandler = func(req *http.Request, res *http.Response, responseJSON interface{}) ([]byte, error) +type ClientResponseHandler = func(req *http.Request, res *http.Response, responseJSON any, sizeLimit int64) ([]byte, error) type FullRequest struct { - Method string - URL string - Headers http.Header - RequestJSON interface{} - RequestBytes []byte - RequestBody io.Reader - RequestLength int64 - ResponseJSON interface{} - MaxAttempts int - BackoffDuration time.Duration - SensitiveContent bool - Handler ClientResponseHandler - DontReadResponse bool - Logger *zerolog.Logger - Client *http.Client + Method string + URL string + Headers http.Header + RequestJSON interface{} + RequestBytes []byte + RequestBody io.Reader + RequestLength int64 + ResponseJSON interface{} + MaxAttempts int + BackoffDuration time.Duration + SensitiveContent bool + Handler ClientResponseHandler + DontReadResponse bool + ResponseSizeLimit int64 + Logger *zerolog.Logger + Client *http.Client } var requestID int32 @@ -537,10 +546,25 @@ func (cli *Client) MakeFullRequestWithResp(ctx context.Context, params FullReque if len(cli.AccessToken) > 0 { req.Header.Set("Authorization", "Bearer "+cli.AccessToken) } + if params.ResponseSizeLimit == 0 { + params.ResponseSizeLimit = cli.ResponseSizeLimit + } + if params.ResponseSizeLimit == 0 { + params.ResponseSizeLimit = DefaultResponseSizeLimit + } if params.Client == nil { params.Client = cli.Client } - return cli.executeCompiledRequest(req, params.MaxAttempts-1, params.BackoffDuration, params.ResponseJSON, params.Handler, params.DontReadResponse, params.Client) + return cli.executeCompiledRequest( + req, + params.MaxAttempts-1, + params.BackoffDuration, + params.ResponseJSON, + params.Handler, + params.DontReadResponse, + params.ResponseSizeLimit, + params.Client, + ) } func (cli *Client) cliOrContextLog(ctx context.Context) *zerolog.Logger { @@ -551,7 +575,17 @@ func (cli *Client) cliOrContextLog(ctx context.Context) *zerolog.Logger { return log } -func (cli *Client) doRetry(req *http.Request, cause error, retries int, backoff time.Duration, responseJSON any, handler ClientResponseHandler, dontReadResponse bool, client *http.Client) ([]byte, *http.Response, error) { +func (cli *Client) doRetry( + req *http.Request, + cause error, + retries int, + backoff time.Duration, + responseJSON any, + handler ClientResponseHandler, + dontReadResponse bool, + sizeLimit int64, + client *http.Client, +) ([]byte, *http.Response, error) { log := zerolog.Ctx(req.Context()) if req.Body != nil { var err error @@ -585,11 +619,23 @@ func (cli *Client) doRetry(req *http.Request, cause error, retries int, backoff if cli.UpdateRequestOnRetry != nil { req = cli.UpdateRequestOnRetry(req, cause) } - return cli.executeCompiledRequest(req, retries-1, backoff*2, responseJSON, handler, dontReadResponse, client) + return cli.executeCompiledRequest(req, retries-1, backoff*2, responseJSON, handler, dontReadResponse, sizeLimit, client) } -func readResponseBody(req *http.Request, res *http.Response) ([]byte, error) { - contents, err := io.ReadAll(res.Body) +func readResponseBody(req *http.Request, res *http.Response, limit int64) ([]byte, error) { + if res.ContentLength > limit { + return nil, HTTPError{ + Request: req, + Response: res, + + Message: "not reading response", + WrappedError: fmt.Errorf("%w (%.2f MiB)", ErrResponseTooLong, float64(res.ContentLength)/1024/1024), + } + } + contents, err := io.ReadAll(io.LimitReader(res.Body, limit+1)) + if err == nil && len(contents) > int(limit) { + err = ErrBodyReadReachedLimit + } if err != nil { return nil, HTTPError{ Request: req, @@ -610,17 +656,20 @@ func closeTemp(log *zerolog.Logger, file *os.File) { } } -func streamResponse(req *http.Request, res *http.Response, responseJSON interface{}) ([]byte, error) { +func streamResponse(req *http.Request, res *http.Response, responseJSON any, limit int64) ([]byte, error) { log := zerolog.Ctx(req.Context()) file, err := os.CreateTemp("", "mautrix-response-") if err != nil { log.Warn().Err(err).Msg("Failed to create temporary file for streaming response") - _, err = handleNormalResponse(req, res, responseJSON) + _, err = handleNormalResponse(req, res, responseJSON, limit) return nil, err } defer closeTemp(log, file) - if _, err = io.Copy(file, res.Body); err != nil { + var n int64 + if n, err = io.Copy(file, io.LimitReader(res.Body, limit+1)); err != nil { return nil, fmt.Errorf("failed to copy response to file: %w", err) + } else if n > limit { + return nil, ErrBodyReadReachedLimit } else if _, err = file.Seek(0, 0); err != nil { return nil, fmt.Errorf("failed to seek to beginning of response file: %w", err) } else if err = json.NewDecoder(file).Decode(responseJSON); err != nil { @@ -630,12 +679,12 @@ func streamResponse(req *http.Request, res *http.Response, responseJSON interfac } } -func noopHandleResponse(req *http.Request, res *http.Response, responseJSON interface{}) ([]byte, error) { +func noopHandleResponse(req *http.Request, res *http.Response, responseJSON any, limit int64) ([]byte, error) { return nil, nil } -func handleNormalResponse(req *http.Request, res *http.Response, responseJSON interface{}) ([]byte, error) { - if contents, err := readResponseBody(req, res); err != nil { +func handleNormalResponse(req *http.Request, res *http.Response, responseJSON any, limit int64) ([]byte, error) { + if contents, err := readResponseBody(req, res, limit); err != nil { return nil, err } else if responseJSON == nil { return contents, nil @@ -653,8 +702,13 @@ func handleNormalResponse(req *http.Request, res *http.Response, responseJSON in } } +const ErrorResponseSizeLimit = 512 * 1024 + +var DefaultResponseSizeLimit int64 = 512 * 1024 * 1024 + func ParseErrorResponse(req *http.Request, res *http.Response) ([]byte, error) { - contents, err := readResponseBody(req, res) + defer res.Body.Close() + contents, err := readResponseBody(req, res, ErrorResponseSizeLimit) if err != nil { return contents, err } @@ -673,7 +727,16 @@ func ParseErrorResponse(req *http.Request, res *http.Response) ([]byte, error) { } } -func (cli *Client) executeCompiledRequest(req *http.Request, retries int, backoff time.Duration, responseJSON any, handler ClientResponseHandler, dontReadResponse bool, client *http.Client) ([]byte, *http.Response, error) { +func (cli *Client) executeCompiledRequest( + req *http.Request, + retries int, + backoff time.Duration, + responseJSON any, + handler ClientResponseHandler, + dontReadResponse bool, + sizeLimit int64, + client *http.Client, +) ([]byte, *http.Response, error) { cli.RequestStart(req) startTime := time.Now() res, err := client.Do(req) @@ -683,7 +746,9 @@ func (cli *Client) executeCompiledRequest(req *http.Request, retries int, backof } if err != nil { if retries > 0 && !errors.Is(err, context.Canceled) { - return cli.doRetry(req, err, retries, backoff, responseJSON, handler, dontReadResponse, client) + return cli.doRetry( + req, err, retries, backoff, responseJSON, handler, dontReadResponse, sizeLimit, client, + ) } err = HTTPError{ Request: req, @@ -698,7 +763,9 @@ func (cli *Client) executeCompiledRequest(req *http.Request, retries int, backof if retries > 0 && retryafter.Should(res.StatusCode, !cli.IgnoreRateLimit) { backoff = retryafter.Parse(res.Header.Get("Retry-After"), backoff) - return cli.doRetry(req, fmt.Errorf("HTTP %d", res.StatusCode), retries, backoff, responseJSON, handler, dontReadResponse, client) + return cli.doRetry( + req, fmt.Errorf("HTTP %d", res.StatusCode), retries, backoff, responseJSON, handler, dontReadResponse, sizeLimit, client, + ) } var body []byte @@ -706,7 +773,7 @@ func (cli *Client) executeCompiledRequest(req *http.Request, retries int, backof body, err = ParseErrorResponse(req, res) cli.LogRequestDone(req, res, nil, nil, len(body), duration) } else { - body, err = handler(req, res, responseJSON) + body, err = handler(req, res, responseJSON, sizeLimit) cli.LogRequestDone(req, res, nil, err, len(body), duration) } return body, res, err @@ -1275,9 +1342,9 @@ func (cli *Client) SendMessageEvent(ctx context.Context, roomID id.RoomID, event return } -// SendStateEvent sends a state event into a room. See https://spec.matrix.org/v1.2/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey +// SendStateEvent sends a state event into a room. See https://spec.matrix.org/v1.16/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey // contentJSON should be a pointer to something that can be encoded as JSON using json.Marshal. -func (cli *Client) SendStateEvent(ctx context.Context, roomID id.RoomID, eventType event.Type, stateKey string, contentJSON interface{}, extra ...ReqSendEvent) (resp *RespSendEvent, err error) { +func (cli *Client) SendStateEvent(ctx context.Context, roomID id.RoomID, eventType event.Type, stateKey string, contentJSON any, extra ...ReqSendEvent) (resp *RespSendEvent, err error) { var req ReqSendEvent if len(extra) > 0 { req = extra[0] @@ -1287,9 +1354,15 @@ func (cli *Client) SendStateEvent(ctx context.Context, roomID id.RoomID, eventTy if req.MeowEventID != "" { queryParams["fi.mau.event_id"] = req.MeowEventID.String() } + if req.TransactionID != "" { + queryParams["fi.mau.transaction_id"] = req.TransactionID + } if req.UnstableDelay > 0 { queryParams["org.matrix.msc4140.delay"] = strconv.FormatInt(req.UnstableDelay.Milliseconds(), 10) } + if req.Timestamp > 0 { + queryParams["ts"] = strconv.FormatInt(req.Timestamp, 10) + } urlData := ClientURLPath{"v3", "rooms", roomID, "state", eventType.String(), stateKey} urlPath := cli.BuildURLWithQuery(urlData, queryParams) @@ -1302,14 +1375,12 @@ func (cli *Client) SendStateEvent(ctx context.Context, roomID id.RoomID, eventTy // SendMassagedStateEvent sends a state event into a room with a custom timestamp. See https://spec.matrix.org/v1.2/client-server-api/#put_matrixclientv3roomsroomidstateeventtypestatekey // contentJSON should be a pointer to something that can be encoded as JSON using json.Marshal. +// +// Deprecated: SendStateEvent accepts a timestamp via ReqSendEvent and should be used instead. func (cli *Client) SendMassagedStateEvent(ctx context.Context, roomID id.RoomID, eventType event.Type, stateKey string, contentJSON interface{}, ts int64) (resp *RespSendEvent, err error) { - urlPath := cli.BuildURLWithQuery(ClientURLPath{"v3", "rooms", roomID, "state", eventType.String(), stateKey}, map[string]string{ - "ts": strconv.FormatInt(ts, 10), + resp, err = cli.SendStateEvent(ctx, roomID, eventType, stateKey, contentJSON, ReqSendEvent{ + Timestamp: ts, }) - _, err = cli.MakeRequest(ctx, http.MethodPut, urlPath, contentJSON, &resp) - if err == nil && cli.StateStore != nil { - cli.updateStoreWithOutgoingEvent(ctx, roomID, eventType, stateKey, contentJSON) - } return } @@ -1628,11 +1699,20 @@ func (cli *Client) FullStateEvent(ctx context.Context, roomID id.RoomID, eventTy } // parseRoomStateArray parses a JSON array as a stream and stores the events inside it in a room state map. -func parseRoomStateArray(_ *http.Request, res *http.Response, responseJSON interface{}) ([]byte, error) { +func parseRoomStateArray(req *http.Request, res *http.Response, responseJSON any, limit int64) ([]byte, error) { + if res.ContentLength > limit { + return nil, HTTPError{ + Request: req, + Response: res, + + Message: "not reading response", + WrappedError: fmt.Errorf("%w (%.2f MiB)", ErrResponseTooLong, float64(res.ContentLength)/1024/1024), + } + } response := make(RoomStateMap) responsePtr := responseJSON.(*map[event.Type]map[string]*event.Event) *responsePtr = response - dec := json.NewDecoder(res.Body) + dec := json.NewDecoder(io.LimitReader(res.Body, limit)) arrayStart, err := dec.Token() if err != nil { @@ -2614,6 +2694,15 @@ func (cli *Client) ReportRoom(ctx context.Context, roomID id.RoomID, reason stri return err } +// AdminWhoIs fetches session information belonging to a specific user. Typically requires being a server admin. +// +// https://spec.matrix.org/v1.15/client-server-api/#get_matrixclientv3adminwhoisuserid +func (cli *Client) AdminWhoIs(ctx context.Context, userID id.UserID) (resp RespWhoIs, err error) { + urlPath := cli.BuildClientURL("v3", "admin", "whois", userID) + _, err = cli.MakeRequest(ctx, http.MethodGet, urlPath, nil, &resp) + return +} + // UnstableGetSuspendedStatus uses MSC4323 to check if a user is suspended. func (cli *Client) UnstableGetSuspendedStatus(ctx context.Context, userID id.UserID) (res *RespSuspended, err error) { urlPath := cli.BuildClientURL("unstable", "uk.timedout.msc4323", "admin", "suspend", userID) diff --git a/vendor/maunium.net/go/mautrix/crypto/goolm/message/decoder.go b/vendor/maunium.net/go/mautrix/crypto/goolm/message/decoder.go index a71cf30..b06756a 100644 --- a/vendor/maunium.net/go/mautrix/crypto/goolm/message/decoder.go +++ b/vendor/maunium.net/go/mautrix/crypto/goolm/message/decoder.go @@ -3,6 +3,9 @@ package message import ( "bytes" "encoding/binary" + "fmt" + + "maunium.net/go/mautrix/crypto/olm" ) type Decoder struct { @@ -20,6 +23,8 @@ func (d *Decoder) ReadVarInt() (uint64, error) { func (d *Decoder) ReadVarBytes() ([]byte, error) { if n, err := d.ReadVarInt(); err != nil { return nil, err + } else if n > uint64(d.Len()) { + return nil, fmt.Errorf("%w: var bytes length says %d, but only %d bytes left", olm.ErrInputToSmall, n, d.Available()) } else { out := make([]byte, n) _, err = d.Read(out) diff --git a/vendor/maunium.net/go/mautrix/crypto/goolm/message/group_message.go b/vendor/maunium.net/go/mautrix/crypto/goolm/message/group_message.go index c2a43b1..f3d2250 100644 --- a/vendor/maunium.net/go/mautrix/crypto/goolm/message/group_message.go +++ b/vendor/maunium.net/go/mautrix/crypto/goolm/message/group_message.go @@ -2,10 +2,12 @@ package message import ( "bytes" + "fmt" "io" "maunium.net/go/mautrix/crypto/goolm/aessha2" "maunium.net/go/mautrix/crypto/goolm/crypto" + "maunium.net/go/mautrix/crypto/olm" ) const ( @@ -36,6 +38,9 @@ func (r *GroupMessage) Decode(input []byte) (err error) { if err != nil { return } + if r.Version != protocolVersion { + return fmt.Errorf("GroupMessage.Decode: %w", olm.ErrWrongProtocolVersion) + } for { // Read Key diff --git a/vendor/maunium.net/go/mautrix/crypto/goolm/message/message.go b/vendor/maunium.net/go/mautrix/crypto/goolm/message/message.go index 8bb6e0c..9ef9363 100644 --- a/vendor/maunium.net/go/mautrix/crypto/goolm/message/message.go +++ b/vendor/maunium.net/go/mautrix/crypto/goolm/message/message.go @@ -2,10 +2,12 @@ package message import ( "bytes" + "fmt" "io" "maunium.net/go/mautrix/crypto/goolm/aessha2" "maunium.net/go/mautrix/crypto/goolm/crypto" + "maunium.net/go/mautrix/crypto/olm" ) const ( @@ -40,6 +42,9 @@ func (r *Message) Decode(input []byte) (err error) { if err != nil { return } + if r.Version != protocolVersion { + return fmt.Errorf("Message.Decode: %w", olm.ErrWrongProtocolVersion) + } for { // Read Key diff --git a/vendor/maunium.net/go/mautrix/crypto/goolm/message/prekey_message.go b/vendor/maunium.net/go/mautrix/crypto/goolm/message/prekey_message.go index 22ebf9c..760be4c 100644 --- a/vendor/maunium.net/go/mautrix/crypto/goolm/message/prekey_message.go +++ b/vendor/maunium.net/go/mautrix/crypto/goolm/message/prekey_message.go @@ -1,6 +1,7 @@ package message import ( + "fmt" "io" "maunium.net/go/mautrix/crypto/goolm/crypto" @@ -22,6 +23,11 @@ type PreKeyMessage struct { Message []byte `json:"message"` } +// TODO deduplicate constant with one in session/olm_session.go +const ( + protocolVersion = 0x3 +) + // Decodes decodes the input and populates the corresponding fileds. func (r *PreKeyMessage) Decode(input []byte) (err error) { r.Version = 0 @@ -41,6 +47,9 @@ func (r *PreKeyMessage) Decode(input []byte) (err error) { } return } + if r.Version != protocolVersion { + return fmt.Errorf("PreKeyMessage.Decode: %w", olm.ErrWrongProtocolVersion) + } for { // Read Key diff --git a/vendor/maunium.net/go/mautrix/error.go b/vendor/maunium.net/go/mautrix/error.go index b7c92a5..826af17 100644 --- a/vendor/maunium.net/go/mautrix/error.go +++ b/vendor/maunium.net/go/mautrix/error.go @@ -67,6 +67,8 @@ var ( MIncompatibleRoomVersion = RespError{ErrCode: "M_INCOMPATIBLE_ROOM_VERSION"} // The client specified a parameter that has the wrong value. MInvalidParam = RespError{ErrCode: "M_INVALID_PARAM", StatusCode: http.StatusBadRequest} + // The client specified a room key backup version that is not the current room key backup version for the user. + MWrongRoomKeysVersion = RespError{ErrCode: "M_WRONG_ROOM_KEYS_VERSION", StatusCode: http.StatusForbidden} MURLNotSet = RespError{ErrCode: "M_URL_NOT_SET"} MBadStatus = RespError{ErrCode: "M_BAD_STATUS"} @@ -80,6 +82,9 @@ var ( var ( ErrClientIsNil = errors.New("client is nil") ErrClientHasNoHomeserver = errors.New("client has no homeserver set") + + ErrResponseTooLong = errors.New("response content length too long") + ErrBodyReadReachedLimit = errors.New("reached response size limit while reading body") ) // HTTPError An HTTP Error response, which may wrap an underlying native Go Error. diff --git a/vendor/maunium.net/go/mautrix/event/capabilities.d.ts b/vendor/maunium.net/go/mautrix/event/capabilities.d.ts index 3784857..1fbc961 100644 --- a/vendor/maunium.net/go/mautrix/event/capabilities.d.ts +++ b/vendor/maunium.net/go/mautrix/event/capabilities.d.ts @@ -16,6 +16,23 @@ export interface RoomFeatures { * If a message type isn't listed here, it should be treated as support level -2 (will be rejected). */ file?: Record + /** + * Supported state event types and their parameters. Currently, there are no parameters, + * but it is likely there will be some in the future (like max name/topic length, avatar mime types, etc.). + * + * Events that are not listed or have a support level of zero or below should be treated as unsupported. + * + * Clients should at least check `m.room.name`, `m.room.topic`, and `m.room.avatar` here. + * `m.room.member` will not be listed here, as it's controlled by the member_actions field. + * `com.beeper.disappearing_timer` should be listed here, but the parameters are in the disappearing_timer field for now. + */ + state?: Record + /** + * Supported member actions and their support levels. + * + * Actions that are not listed or have a support level of zero or below should be treated as unsupported. + */ + member_actions?: Record /** Maximum length of normal text messages. */ max_text_length?: integer @@ -72,6 +89,21 @@ declare type MIMETypeOrPattern = | `${MIMEClass}/${string}` | `${MIMEClass}/${string}; ${string}` +export enum MemberAction { + Ban = "ban", + Kick = "kick", + Leave = "leave", + RevokeInvite = "revoke_invite", + Invite = "invite", +} + +declare type EventType = string + +// This is an object for future extensibility (e.g. max name/topic length) +export interface StateFeatures { + level: CapabilitySupportLevel +} + export enum CapabilityMsgType { // Real message types used in the `msgtype` field Image = "m.image", diff --git a/vendor/maunium.net/go/mautrix/event/capabilities.go b/vendor/maunium.net/go/mautrix/event/capabilities.go index 42afe5b..4b7ff18 100644 --- a/vendor/maunium.net/go/mautrix/event/capabilities.go +++ b/vendor/maunium.net/go/mautrix/event/capabilities.go @@ -28,8 +28,10 @@ type RoomFeatures struct { // N.B. New fields need to be added to the Hash function to be included in the deduplication hash. - Formatting FormattingFeatureMap `json:"formatting,omitempty"` - File FileFeatureMap `json:"file,omitempty"` + Formatting FormattingFeatureMap `json:"formatting,omitempty"` + File FileFeatureMap `json:"file,omitempty"` + State StateFeatureMap `json:"state,omitempty"` + MemberActions MemberFeatureMap `json:"member_actions,omitempty"` MaxTextLength int `json:"max_text_length,omitempty"` @@ -58,6 +60,8 @@ type RoomFeatures struct { MarkAsUnread bool `json:"mark_as_unread,omitempty"` DeleteChat bool `json:"delete_chat,omitempty"` DeleteChatForEveryone bool `json:"delete_chat_for_everyone,omitempty"` + + PerMessageProfileRelay bool `json:"-"` } func (rf *RoomFeatures) GetID() string { @@ -74,6 +78,8 @@ func (rf *RoomFeatures) Clone() *RoomFeatures { clone := *rf clone.File = clone.File.Clone() clone.Formatting = maps.Clone(clone.Formatting) + clone.State = clone.State.Clone() + clone.MemberActions = clone.MemberActions.Clone() clone.EditMaxAge = ptr.Clone(clone.EditMaxAge) clone.DeleteMaxAge = ptr.Clone(clone.DeleteMaxAge) clone.DisappearingTimer = clone.DisappearingTimer.Clone() @@ -81,6 +87,48 @@ func (rf *RoomFeatures) Clone() *RoomFeatures { return &clone } +type MemberFeatureMap map[MemberAction]CapabilitySupportLevel + +func (mfm MemberFeatureMap) Clone() MemberFeatureMap { + return maps.Clone(mfm) +} + +type MemberAction string + +const ( + MemberActionBan MemberAction = "ban" + MemberActionKick MemberAction = "kick" + MemberActionLeave MemberAction = "leave" + MemberActionRevokeInvite MemberAction = "revoke_invite" + MemberActionInvite MemberAction = "invite" +) + +type StateFeatureMap map[string]*StateFeatures + +func (sfm StateFeatureMap) Clone() StateFeatureMap { + dup := maps.Clone(sfm) + for key, value := range dup { + dup[key] = value.Clone() + } + return dup +} + +type StateFeatures struct { + Level CapabilitySupportLevel `json:"level"` +} + +func (sf *StateFeatures) Clone() *StateFeatures { + if sf == nil { + return nil + } + clone := *sf + return &clone +} + +func (sf *StateFeatures) Hash() []byte { + return sf.Level.Hash() +} + type FormattingFeatureMap map[FormattingFeature]CapabilitySupportLevel type FileFeatureMap map[CapabilityMsgType]*FileFeatures @@ -266,6 +314,8 @@ func (rf *RoomFeatures) Hash() []byte { hashMap(hasher, "formatting", rf.Formatting) hashMap(hasher, "file", rf.File) + hashMap(hasher, "state", rf.State) + hashMap(hasher, "member_actions", rf.MemberActions) hashInt(hasher, "max_text_length", rf.MaxTextLength) diff --git a/vendor/maunium.net/go/mautrix/event/powerlevels.go b/vendor/maunium.net/go/mautrix/event/powerlevels.go index 50df2c1..708721f 100644 --- a/vendor/maunium.net/go/mautrix/event/powerlevels.go +++ b/vendor/maunium.net/go/mautrix/event/powerlevels.go @@ -132,9 +132,19 @@ func (pl *PowerLevelsEventContent) GetUserLevel(userID id.UserID) int { return level } +const maxPL = 1<<53 - 1 + func (pl *PowerLevelsEventContent) SetUserLevel(userID id.UserID, level int) { pl.usersLock.Lock() defer pl.usersLock.Unlock() + if pl.isCreator(userID) { + return + } + if level == math.MaxInt && maxPL < math.MaxInt { + // Hack to avoid breaking on 32-bit systems (they're only slightly supported) + x := int64(maxPL) + level = int(x) + } if level == pl.UsersDefault { delete(pl.Users, userID) } else { diff --git a/vendor/maunium.net/go/mautrix/event/reply.go b/vendor/maunium.net/go/mautrix/event/reply.go index 9ae1c11..5f55bb8 100644 --- a/vendor/maunium.net/go/mautrix/event/reply.go +++ b/vendor/maunium.net/go/mautrix/event/reply.go @@ -32,12 +32,13 @@ func TrimReplyFallbackText(text string) string { } func (content *MessageEventContent) RemoveReplyFallback() { - if len(content.RelatesTo.GetReplyTo()) > 0 && !content.replyFallbackRemoved { - if content.Format == FormatHTML { - content.FormattedBody = TrimReplyFallbackHTML(content.FormattedBody) + if len(content.RelatesTo.GetReplyTo()) > 0 && !content.replyFallbackRemoved && content.Format == FormatHTML { + origHTML := content.FormattedBody + content.FormattedBody = TrimReplyFallbackHTML(content.FormattedBody) + if content.FormattedBody != origHTML { + content.Body = TrimReplyFallbackText(content.Body) + content.replyFallbackRemoved = true } - content.Body = TrimReplyFallbackText(content.Body) - content.replyFallbackRemoved = true } } diff --git a/vendor/maunium.net/go/mautrix/event/state.go b/vendor/maunium.net/go/mautrix/event/state.go index ed5434c..6df3b14 100644 --- a/vendor/maunium.net/go/mautrix/event/state.go +++ b/vendor/maunium.net/go/mautrix/event/state.go @@ -96,6 +96,13 @@ type TombstoneEventContent struct { ReplacementRoom id.RoomID `json:"replacement_room"` } +func (tec *TombstoneEventContent) GetReplacementRoom() id.RoomID { + if tec == nil { + return "" + } + return tec.ReplacementRoom +} + type Predecessor struct { RoomID id.RoomID `json:"room_id"` EventID id.EventID `json:"event_id"` @@ -135,6 +142,13 @@ type CreateEventContent struct { Creator id.UserID `json:"creator,omitempty"` } +func (cec *CreateEventContent) GetPredecessor() (p Predecessor) { + if cec != nil && cec.Predecessor != nil { + p = *cec.Predecessor + } + return +} + func (cec *CreateEventContent) SupportsCreatorPower() bool { if cec == nil { return false @@ -232,7 +246,8 @@ type BridgeEventContent struct { BeeperRoomType string `json:"com.beeper.room_type,omitempty"` BeeperRoomTypeV2 string `json:"com.beeper.room_type.v2,omitempty"` - TempSlackRemoteIDMigratedFlag bool `json:"com.beeper.slack_remote_id_migrated,omitempty"` + TempSlackRemoteIDMigratedFlag bool `json:"com.beeper.slack_remote_id_migrated,omitempty"` + TempSlackRemoteIDMigratedFlag2 bool `json:"com.beeper.slack_remote_id_really_migrated,omitempty"` } // DisappearingType represents the type of a disappearing message timer. diff --git a/vendor/maunium.net/go/mautrix/responses.go b/vendor/maunium.net/go/mautrix/responses.go index 3484c13..e7b6b75 100644 --- a/vendor/maunium.net/go/mautrix/responses.go +++ b/vendor/maunium.net/go/mautrix/responses.go @@ -6,12 +6,14 @@ import ( "fmt" "maps" "reflect" + "slices" "strconv" "strings" "github.com/tidwall/gjson" "github.com/tidwall/sjson" "go.mau.fi/util/jsontime" + "go.mau.fi/util/ptr" "maunium.net/go/mautrix/event" "maunium.net/go/mautrix/id" @@ -342,6 +344,17 @@ type LazyLoadSummary struct { InvitedMemberCount *int `json:"m.invited_member_count,omitempty"` } +func (lls *LazyLoadSummary) Equal(other *LazyLoadSummary) bool { + if lls == other { + return true + } else if lls == nil || other == nil { + return false + } + return ptr.Val(lls.JoinedMemberCount) == ptr.Val(other.JoinedMemberCount) && + ptr.Val(lls.InvitedMemberCount) == ptr.Val(other.InvitedMemberCount) && + slices.Equal(lls.Heroes, other.Heroes) +} + type SyncEventsList struct { Events []*event.Event `json:"events,omitempty"` } @@ -755,3 +768,23 @@ type RespSuspended struct { type RespLocked struct { Locked bool `json:"locked"` } + +type ConnectionInfo struct { + IP string `json:"ip,omitempty"` + LastSeen jsontime.UnixMilli `json:"last_seen,omitempty"` + UserAgent string `json:"user_agent,omitempty"` +} + +type SessionInfo struct { + Connections []ConnectionInfo `json:"connections,omitempty"` +} + +type DeviceInfo struct { + Sessions []SessionInfo `json:"sessions,omitempty"` +} + +// RespWhoIs is the response body for https://spec.matrix.org/v1.15/client-server-api/#get_matrixclientv3adminwhoisuserid +type RespWhoIs struct { + UserID id.UserID `json:"user_id,omitempty"` + Devices map[id.DeviceID]DeviceInfo `json:"devices,omitempty"` +} diff --git a/vendor/maunium.net/go/mautrix/sqlstatestore/statestore.go b/vendor/maunium.net/go/mautrix/sqlstatestore/statestore.go index c412680..11957df 100644 --- a/vendor/maunium.net/go/mautrix/sqlstatestore/statestore.go +++ b/vendor/maunium.net/go/mautrix/sqlstatestore/statestore.go @@ -470,3 +470,26 @@ func (store *SQLStateStore) GetCreate(ctx context.Context, roomID id.RoomID) (ev } return } + +func (store *SQLStateStore) SetJoinRules(ctx context.Context, roomID id.RoomID, rules *event.JoinRulesEventContent) error { + if roomID == "" { + return fmt.Errorf("room ID is empty") + } + _, err := store.Exec(ctx, ` + INSERT INTO mx_room_state (room_id, join_rules) VALUES ($1, $2) + ON CONFLICT (room_id) DO UPDATE SET join_rules=excluded.join_rules + `, roomID, dbutil.JSON{Data: rules}) + return err +} + +func (store *SQLStateStore) GetJoinRules(ctx context.Context, roomID id.RoomID) (levels *event.JoinRulesEventContent, err error) { + levels = &event.JoinRulesEventContent{} + err = store. + QueryRow(ctx, "SELECT join_rules FROM mx_room_state WHERE room_id=$1 AND join_rules IS NOT NULL", roomID). + Scan(&dbutil.JSON{Data: &levels}) + if errors.Is(err, sql.ErrNoRows) { + levels = nil + err = nil + } + return +} diff --git a/vendor/maunium.net/go/mautrix/sqlstatestore/v00-latest-revision.sql b/vendor/maunium.net/go/mautrix/sqlstatestore/v00-latest-revision.sql index b5a858e..4679f1c 100644 --- a/vendor/maunium.net/go/mautrix/sqlstatestore/v00-latest-revision.sql +++ b/vendor/maunium.net/go/mautrix/sqlstatestore/v00-latest-revision.sql @@ -1,4 +1,4 @@ --- v0 -> v9 (compatible with v3+): Latest revision +-- v0 -> v10 (compatible with v3+): Latest revision CREATE TABLE mx_registrations ( user_id TEXT PRIMARY KEY @@ -27,5 +27,6 @@ CREATE TABLE mx_room_state ( power_levels jsonb, encryption jsonb, create_event jsonb, + join_rules jsonb, members_fetched BOOLEAN NOT NULL DEFAULT false ); diff --git a/vendor/maunium.net/go/mautrix/sqlstatestore/v10-join-rules.sql b/vendor/maunium.net/go/mautrix/sqlstatestore/v10-join-rules.sql new file mode 100644 index 0000000..3074c46 --- /dev/null +++ b/vendor/maunium.net/go/mautrix/sqlstatestore/v10-join-rules.sql @@ -0,0 +1,2 @@ +-- v10 (compatible with v3+): Add join rules to room state table +ALTER TABLE mx_room_state ADD COLUMN join_rules jsonb; diff --git a/vendor/maunium.net/go/mautrix/statestore.go b/vendor/maunium.net/go/mautrix/statestore.go index 1933ab9..c6267c5 100644 --- a/vendor/maunium.net/go/mautrix/statestore.go +++ b/vendor/maunium.net/go/mautrix/statestore.go @@ -37,6 +37,9 @@ type StateStore interface { SetCreate(ctx context.Context, evt *event.Event) error GetCreate(ctx context.Context, roomID id.RoomID) (*event.Event, error) + GetJoinRules(ctx context.Context, roomID id.RoomID) (*event.JoinRulesEventContent, error) + SetJoinRules(ctx context.Context, roomID id.RoomID, content *event.JoinRulesEventContent) error + HasFetchedMembers(ctx context.Context, roomID id.RoomID) (bool, error) MarkMembersFetched(ctx context.Context, roomID id.RoomID) error GetAllMembers(ctx context.Context, roomID id.RoomID) (map[id.UserID]*event.MemberEventContent, error) @@ -73,6 +76,8 @@ func UpdateStateStore(ctx context.Context, store StateStore, evt *event.Event) { err = store.SetEncryptionEvent(ctx, evt.RoomID, content) case *event.CreateEventContent: err = store.SetCreate(ctx, evt) + case *event.JoinRulesEventContent: + err = store.SetJoinRules(ctx, evt.RoomID, content) default: switch evt.Type { case event.StateMember, event.StatePowerLevels, event.StateEncryption, event.StateCreate: @@ -107,11 +112,13 @@ type MemoryStateStore struct { PowerLevels map[id.RoomID]*event.PowerLevelsEventContent `json:"power_levels"` Encryption map[id.RoomID]*event.EncryptionEventContent `json:"encryption"` Create map[id.RoomID]*event.Event `json:"create"` + JoinRules map[id.RoomID]*event.JoinRulesEventContent `json:"join_rules"` registrationsLock sync.RWMutex membersLock sync.RWMutex powerLevelsLock sync.RWMutex encryptionLock sync.RWMutex + joinRulesLock sync.RWMutex } func NewMemoryStateStore() StateStore { @@ -354,6 +361,19 @@ func (store *MemoryStateStore) GetEncryptionEvent(_ context.Context, roomID id.R return store.Encryption[roomID], nil } +func (store *MemoryStateStore) SetJoinRules(ctx context.Context, roomID id.RoomID, content *event.JoinRulesEventContent) error { + store.joinRulesLock.Lock() + store.JoinRules[roomID] = content + store.joinRulesLock.Unlock() + return nil +} + +func (store *MemoryStateStore) GetJoinRules(ctx context.Context, roomID id.RoomID) (*event.JoinRulesEventContent, error) { + store.joinRulesLock.RLock() + defer store.joinRulesLock.RUnlock() + return store.JoinRules[roomID], nil +} + func (store *MemoryStateStore) IsEncrypted(ctx context.Context, roomID id.RoomID) (bool, error) { cfg, err := store.GetEncryptionEvent(ctx, roomID) return cfg != nil && cfg.Algorithm == id.AlgorithmMegolmV1, err diff --git a/vendor/maunium.net/go/mautrix/version.go b/vendor/maunium.net/go/mautrix/version.go index 7b4eea4..f6d20c3 100644 --- a/vendor/maunium.net/go/mautrix/version.go +++ b/vendor/maunium.net/go/mautrix/version.go @@ -8,7 +8,7 @@ import ( "strings" ) -const Version = "v0.25.2" +const Version = "v0.26.0" var GoModVersion = "" var Commit = "" diff --git a/vendor/maunium.net/go/mautrix/versions.go b/vendor/maunium.net/go/mautrix/versions.go index 0392532..2aaf639 100644 --- a/vendor/maunium.net/go/mautrix/versions.go +++ b/vendor/maunium.net/go/mautrix/versions.go @@ -69,14 +69,16 @@ var ( FeatureAccountModeration = UnstableFeature{UnstableFlag: "uk.timedout.msc4323"} FeatureUnstableProfileFields = UnstableFeature{UnstableFlag: "uk.tcpip.msc4133"} FeatureArbitraryProfileFields = UnstableFeature{UnstableFlag: "uk.tcpip.msc4133.stable", SpecVersion: SpecV116} + FeatureRedactSendAsEvent = UnstableFeature{UnstableFlag: "com.beeper.msc4169"} - BeeperFeatureHungry = UnstableFeature{UnstableFlag: "com.beeper.hungry"} - BeeperFeatureBatchSending = UnstableFeature{UnstableFlag: "com.beeper.batch_sending"} - BeeperFeatureRoomYeeting = UnstableFeature{UnstableFlag: "com.beeper.room_yeeting"} - BeeperFeatureAutojoinInvites = UnstableFeature{UnstableFlag: "com.beeper.room_create_autojoin_invites"} - BeeperFeatureArbitraryProfileMeta = UnstableFeature{UnstableFlag: "com.beeper.arbitrary_profile_meta"} - BeeperFeatureAccountDataMute = UnstableFeature{UnstableFlag: "com.beeper.account_data_mute"} - BeeperFeatureInboxState = UnstableFeature{UnstableFlag: "com.beeper.inbox_state"} + BeeperFeatureHungry = UnstableFeature{UnstableFlag: "com.beeper.hungry"} + BeeperFeatureBatchSending = UnstableFeature{UnstableFlag: "com.beeper.batch_sending"} + BeeperFeatureRoomYeeting = UnstableFeature{UnstableFlag: "com.beeper.room_yeeting"} + BeeperFeatureAutojoinInvites = UnstableFeature{UnstableFlag: "com.beeper.room_create_autojoin_invites"} + BeeperFeatureArbitraryProfileMeta = UnstableFeature{UnstableFlag: "com.beeper.arbitrary_profile_meta"} + BeeperFeatureAccountDataMute = UnstableFeature{UnstableFlag: "com.beeper.account_data_mute"} + BeeperFeatureInboxState = UnstableFeature{UnstableFlag: "com.beeper.inbox_state"} + BeeperFeatureArbitraryMemberChange = UnstableFeature{UnstableFlag: "com.beeper.arbitrary_member_change"} ) func (versions *RespVersions) Supports(feature UnstableFeature) bool { diff --git a/vendor/modernc.org/libc/AUTHORS b/vendor/modernc.org/libc/AUTHORS index 5d443d9..7944c59 100644 --- a/vendor/modernc.org/libc/AUTHORS +++ b/vendor/modernc.org/libc/AUTHORS @@ -10,6 +10,7 @@ Dan Kortschak Dan Peterson +David Leadbeater Fabrice Colliot Jan Mercl <0xjnml@gmail.com> Jason DeBettencourt diff --git a/vendor/modernc.org/libc/CONTRIBUTORS b/vendor/modernc.org/libc/CONTRIBUTORS index c25a262..c9fdd4e 100644 --- a/vendor/modernc.org/libc/CONTRIBUTORS +++ b/vendor/modernc.org/libc/CONTRIBUTORS @@ -6,15 +6,17 @@ # # Please keep the list sorted. +Bjørn Wiegell Dan Kortschak Dan Peterson -Bjørn Wiegell +David Leadbeater Fabrice Colliot Jaap Aarts Jan Mercl <0xjnml@gmail.com> Jason DeBettencourt Jasper Siepkes Koichi Shiraishi +Leonardo Taccari Marius Orcsik Patricio Whittingslow Roman Khafizianov diff --git a/vendor/modernc.org/libc/ccgo_linux_386.go b/vendor/modernc.org/libc/ccgo_linux_386.go index 91ec9c9..87b4a92 100644 --- a/vendor/modernc.org/libc/ccgo_linux_386.go +++ b/vendor/modernc.org/libc/ccgo_linux_386.go @@ -582,14 +582,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -598,8 +598,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -930,18 +930,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -973,9 +973,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int32(t) /* the multiple */ t = float64(i) @@ -1025,9 +1025,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int32(t) /* the multiple */ t = float32(i) @@ -1071,18 +1071,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1090,18 +1090,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1160,8 +1160,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1182,42 +1182,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1231,11 +1231,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1245,17 +1245,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1266,11 +1266,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1283,17 +1283,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1306,11 +1306,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1322,8 +1322,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1339,92 +1339,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1457,14 +1457,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1478,32 +1478,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1522,11 +1522,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1541,12 +1541,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1558,32 +1558,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1602,11 +1602,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1873,18 +1873,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1892,18 +1892,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1916,8 +1916,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1938,42 +1938,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1987,11 +1987,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2000,17 +2000,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2021,11 +2021,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2040,17 +2040,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2063,11 +2063,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2079,8 +2079,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2096,92 +2096,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2225,13 +2225,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2246,29 +2246,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2299,8 +2299,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2308,22 +2308,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2345,13 +2345,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2366,29 +2366,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2396,21 +2396,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2424,18 +2424,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2458,18 +2458,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2477,18 +2477,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2499,15 +2499,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2550,15 +2550,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2601,11 +2601,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2615,15 +2615,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2648,50 +2648,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7566,12 +7566,12 @@ func Xsysconf(tls *TLS, name int32) (r int32) { bp := tls.Alloc(464) defer tls.Free(464) var cnt, i, val, v3 int32 - var mem, v1, v6 uint64 - var p5 uintptr + var mem, v1 uint64 + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint32FromInt32(name) >= Uint32FromInt64(502)/Uint32FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) @@ -7627,14 +7627,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return cnt case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7649,14 +7649,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { } else { mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram) } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= uint64(PAGESIZE) + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffff) { - v6 = uint64(0x7fffffff) + v1 = uint64(0x7fffffff) } else { - v6 = mem + v1 = mem } - return Int32FromUint64(v6) + return Int32FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7665,7 +7665,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { val = int32(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int32(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int32(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -9041,16 +9041,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9059,10 +9059,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9071,16 +9071,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9089,16 +9089,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9107,58 +9107,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9178,7 +9178,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9189,12 +9189,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9202,36 +9202,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9239,9 +9239,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9250,10 +9250,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9300,9 +9300,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9319,25 +9319,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9348,11 +9348,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9377,7 +9377,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9390,7 +9390,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9407,13 +9407,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9426,7 +9426,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9451,7 +9451,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9459,7 +9459,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9478,9 +9478,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9489,7 +9489,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) @@ -11372,7 +11372,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11399,14 +11399,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11416,8 +11416,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11452,35 +11452,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11493,10 +11493,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11510,19 +11510,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11533,7 +11533,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11549,10 +11549,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11561,7 +11561,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11571,23 +11571,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11618,12 +11618,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11633,10 +11633,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11656,11 +11656,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11675,11 +11675,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11691,12 +11691,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11905,7 +11905,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11913,60 +11913,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11979,7 +11979,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint32(64)-r) @@ -12023,7 +12023,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12040,8 +12040,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint32(64)-r) - len1 -= uint32(64) - r - p += uintptr(uint32(64) - r) + len1 = len1 - (uint32(64) - r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -12052,8 +12052,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(64) - p += uintptr(64) + len1 = len1 - uint32(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -12093,15 +12093,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12132,7 +12132,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12154,7 +12154,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _2 _2: ; - i -= uint32(16) + i = i - uint32(16) } _md5_update(tls, bp, bp+88, i) (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) @@ -12171,7 +12171,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12201,13 +12201,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint32(3)+slen) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v5)) = int8('$') i = uint32(0) for { @@ -12218,7 +12218,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -12418,7 +12418,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12428,7 +12428,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12456,7 +12456,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12473,7 +12473,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint32(64)-r) @@ -12521,7 +12521,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12538,8 +12538,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint32(64)-r) - len1 -= uint32(64) - r - p += uintptr(uint32(64) - r) + len1 = len1 - (uint32(64) - r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12550,8 +12550,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(64) - p += uintptr(64) + len1 = len1 - uint32(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12563,15 +12563,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12595,7 +12595,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, i) } @@ -12637,7 +12637,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint32FromInt64(8) - Uint32FromInt32(1)) + salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12670,7 +12670,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12697,7 +12697,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12711,7 +12711,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12725,7 +12725,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12755,11 +12755,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+232, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+232, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12769,7 +12769,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint32(128)-r) @@ -13079,7 +13079,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -13096,8 +13096,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint32(128)-r) - len1 -= uint32(128) - r - p += uintptr(uint32(128) - r) + len1 = len1 - (uint32(128) - r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -13108,8 +13108,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(128) - p += uintptr(128) + len1 = len1 - uint32(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -13121,15 +13121,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13153,7 +13153,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, i) } @@ -13180,7 +13180,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13205,7 +13205,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint32FromInt64(8) - Uint32FromInt32(1)) + salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13238,7 +13238,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13265,7 +13265,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13279,7 +13279,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13293,7 +13293,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13323,11 +13323,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+424, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+424, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13337,7 +13337,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -13485,9 +13485,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13499,18 +13499,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17628,8 +17628,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint32(0) } @@ -22346,7 +22346,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22385,10 +22385,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22454,15 +22454,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22473,15 +22473,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -25050,10 +25050,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint32(0) @@ -25088,16 +25088,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint32(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint32(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4))) @@ -25167,7 +25167,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25280,7 +25280,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 4 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25382,7 +25382,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25394,7 +25394,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*4)) = new1 } @@ -25839,7 +25839,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25863,7 +25863,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25907,7 +25907,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint32(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint32(O_LARGEFILE) + arg = arg | uint32(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_fcntl64), fd, cmd, int32(uintptr(arg)), 0, 0, 0))) @@ -26174,15 +26174,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26191,23 +26191,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 4 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26217,18 +26217,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 4 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26236,58 +26236,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 4 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26312,7 +26312,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26322,32 +26322,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 4 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 4 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26363,7 +26363,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26372,15 +26372,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26391,14 +26391,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26408,7 +26408,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26416,11 +26416,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26452,12 +26452,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26482,19 +26482,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26507,24 +26507,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26585,7 +26585,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26596,11 +26596,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26612,29 +26612,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26647,40 +26647,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26707,11 +26707,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26725,7 +26725,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26741,26 +26741,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 4 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26772,15 +26772,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 4 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26804,41 +26804,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 4 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26850,15 +26850,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26868,10 +26868,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26885,13 +26885,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26903,11 +26903,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26919,10 +26919,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26941,7 +26941,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26957,16 +26957,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint32(0) for { @@ -26975,24 +26975,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint32(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 4 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint32(3) || i == uint32(8) || i > uint32(3) && pok != 0 { if i != uint32(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -27000,12 +27000,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -27019,55 +27019,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint32(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 4 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint32(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 4 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint32(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 4 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27075,26 +27075,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27102,19 +27102,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 4 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27388,11 +27388,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27403,7 +27403,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27421,42 +27421,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 4 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27475,7 +27475,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27489,18 +27489,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 4 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27508,18 +27508,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 4 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27533,18 +27533,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27667,7 +27667,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') @@ -27682,21 +27682,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27739,7 +27739,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28115,9 +28115,9 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v4 uintptr + var v3 uintptr var v5 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v5 if ts != 0 { v1 = (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec } else { @@ -28156,11 +28156,11 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int 0: int32(Int32FromUint64(v5)), 1: ns, } - v4 = bp + 16 + v3 = bp + 16 } else { - v4 = uintptr(0) + v3 = uintptr(0) } - ts = v4 + ts = v3 return X__syscall_ret(tls, Uint32FromInt32(X__syscall6(tls, int32(SYS_ipc), int32(Int32FromInt32(IPCOP_semtimedop)), id, Int32FromUint32(n), int32(Int32FromInt32(0)), int32(buf), int32(ts)))) } @@ -28599,7 +28599,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28806,7 +28806,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint32(128)) if l >= 0 { if l > 0 && int32(_password[l-int32(1)]) == int32('\n') || Uint32FromInt32(l) == uint32(128) { - l-- + l = l - 1 } _password[l] = 0 } @@ -29299,7 +29299,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int32FromInt32(1000000)) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30556,7 +30556,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_prctl), op, Int32FromUint32(x[0]), Int32FromUint32(x[int32(1)]), Int32FromUint32(x[int32(2)]), Int32FromUint32(x[int32(3)])))) @@ -31613,8 +31613,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if n >= size/uint32(4) || o >= size-uint32(4)*n || t >= size-uint32(4)*n || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31634,10 +31634,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31726,10 +31726,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint32(1)) + trans = trans + uintptr(l+uint32(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98579,7 +98579,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98587,8 +98587,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98612,16 +98612,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint32(1)) + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) } return Uint32FromInt32(int32(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint32(1)) + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98688,23 +98688,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98745,10 +98745,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98766,10 +98766,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(48) defer tls.Free(48) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+40 */ uintptr var _ /* st at bp+16 */ Tmbstate_t @@ -98779,7 +98779,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+44 */ [4]int8 var _ /* wc at bp+24 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint32(0) scd = uintptr(0) if !(uint32(cd)&Uint32FromInt32(1) != 0) { @@ -98967,11 +98967,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint32(4) } @@ -98984,7 +98984,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint32(2) @@ -98993,27 +98993,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -99039,11 +99039,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -99102,8 +99102,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -99116,7 +99116,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -99140,7 +99140,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -99165,13 +99165,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -99189,28 +99189,28 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) - c += k + c = c + k goto _29 _29: } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -99227,18 +99227,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -99310,7 +99310,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -99328,20 +99328,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) - c += k + c = c + k goto _32 _32: } @@ -99429,7 +99429,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -99449,7 +99449,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(1) goto _51 @@ -99467,7 +99467,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99476,17 +99476,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99498,24 +99498,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*int8)(unsafe.Pointer(v57)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v60)) = Int8FromUint32(v62) + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) goto _51 _40: @@ -99524,7 +99524,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99534,14 +99534,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*int8)(unsafe.Pointer(v63)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*int8)(unsafe.Pointer(v65)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) goto _51 _41: @@ -99553,56 +99553,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*int8)(unsafe.Pointer(v67)) = int8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*int8)(unsafe.Pointer(v69)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*int8)(unsafe.Pointer(v71)) = int8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*int8)(unsafe.Pointer(v73)) = int8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*int8)(unsafe.Pointer(v75)) = int8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*int8)(unsafe.Pointer(v77)) = int8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*int8)(unsafe.Pointer(v79)) = int8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*int8)(unsafe.Pointer(v81)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*int8)(unsafe.Pointer(v83)) = int8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*int8)(unsafe.Pointer(v85)) = int8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*int8)(unsafe.Pointer(v87)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(7) goto _51 } @@ -99613,38 +99613,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*int8)(unsafe.Pointer(v89)) = int8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*int8)(unsafe.Pointer(v91)) = int8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*int8)(unsafe.Pointer(v93)) = int8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*int8)(unsafe.Pointer(v95)) = Int8FromUint32(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*int8)(unsafe.Pointer(v97)) = Int8FromUint32(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*int8)(unsafe.Pointer(v99)) = int8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*int8)(unsafe.Pointer(v101)) = int8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*int8)(unsafe.Pointer(v103)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(8) goto _51 _42: @@ -99675,7 +99675,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99752,8 +99752,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99767,11 +99767,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 } else { - v2 = __ccgo_ts + 447 + v1 = __ccgo_ts + 447 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99808,13 +99808,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4))) @@ -99883,11 +99883,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]int8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*int8)(unsafe.Pointer(val)) != 0) { @@ -99916,7 +99916,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 456 @@ -99984,11 +99984,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint32(36)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint32(36)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+8, val, n) @@ -100092,7 +100092,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -100120,7 +100120,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -100197,7 +100197,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -100208,7 +100208,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100318,7 +100318,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -100332,7 +100332,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint32 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -100376,7 +100376,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint32 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100432,10 +100432,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(48) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+24 */ [24]int8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100471,7 +100471,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100484,7 +100484,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 8 @@ -100495,22 +100495,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') - s += uintptr(l + uint32(1)) + s = s + uintptr(l+uint32(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = 0 + s = s - 1 + v3 = s + *(*int8)(unsafe.Pointer(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100523,11 +100523,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) } if lm != 0 { - v6 = lm + 8 + v3 = lm + 8 } else { - v6 = __ccgo_ts + 447 + v3 = __ccgo_ts + 447 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100561,9 +100561,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100577,15 +100577,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100597,9 +100597,9 @@ _4: for { switch int32(*(*int8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = int32(*(*int8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100620,7 +100620,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100631,13 +100631,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100646,12 +100646,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100660,12 +100660,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100676,8 +100676,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return -int32(1) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100872,9 +100872,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 32 @@ -100887,11 +100887,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -101091,12 +101091,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -101116,11 +101116,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - Tdouble_t(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101501,12 +101501,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101631,10 +101631,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101662,8 +101662,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101677,17 +101677,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101707,18 +101707,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101731,7 +101731,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101750,7 +101750,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101764,7 +101764,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101776,11 +101776,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101791,7 +101791,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101805,37 +101805,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101849,11 +101849,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101867,17 +101867,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101899,18 +101899,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101922,38 +101922,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101969,7 +101969,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101985,7 +101985,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101993,11 +101993,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -102063,13 +102063,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -102226,12 +102226,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -102273,11 +102273,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102928,11 +102928,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (Tdouble_t(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102947,14 +102947,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -103032,11 +103032,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -103149,11 +103149,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -103289,11 +103289,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = float64(_atanhi1[id]) - (Tfloat_t(float64(x3)*(s1+s2)) - float64(_atanlo1[id]) - float64(x3)) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return float32(v4) + return float32(v3) } // C documentation @@ -103837,7 +103837,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { var _ /* y at bp+0 */ [2]float64 _, _, _, _, _ = ix, n, y, y1, y2 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103895,12 +103895,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103936,11 +103936,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -104214,7 +104214,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -104249,12 +104249,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -104281,11 +104281,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -104399,7 +104399,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -104434,12 +104434,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104466,11 +104466,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104506,11 +104506,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104597,13 +104597,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104796,11 +104796,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits -= Uint64FromUint64(1) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104876,14 +104876,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104891,13 +104891,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104951,9 +104951,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104978,13 +104978,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -105083,13 +105083,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -105224,7 +105224,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (Tdouble_t(x3*e) - hxs) } e = Tdouble_t(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(Tdouble_t(Float64FromFloat64(0.5)*(x3-e)) - Float64FromFloat64(0.5)) @@ -105302,7 +105302,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -105359,7 +105359,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(float64(x3) - (Tfloat_t(float64(x3)*e) - hxs)) } e = Tfloat_t(float64(x3)*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Tfloat_t(Float64FromFloat32(0.5)*(float64(x3)-e)) - Float64FromFloat32(0.5)) @@ -105459,13 +105459,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105474,10 +105474,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105495,13 +105495,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105510,10 +105510,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105729,7 +105729,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105741,10 +105741,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix &= Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105856,7 +105856,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) if v1>>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) @@ -105870,15 +105870,15 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>Int32FromInt32(32) != 0 { - v5 = _a_clz_32(tls, uint32(v4>>int32(32))) + v1 = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + if v1>>Int32FromInt32(32) != 0 { + v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _6 } - v5 = _a_clz_32(tls, uint32(v4)) + int32(32) + v2 = _a_clz_32(tls, uint32(v1)) + int32(32) goto _6 _6: - d = v5 - int32(1) + d = v2 - int32(1) if d < 0 { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105889,7 +105889,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { return float64(x1*y) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105922,7 +105922,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) - r += float64(Tdouble_t(tiny*tiny) * (r - r)) + r = r + float64(Tdouble_t(tiny*tiny)*(r-r)) } } else { /* only round once when scaled */ @@ -105955,13 +105955,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105970,27 +105970,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105998,11 +105998,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -106012,13 +106012,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -106027,27 +106027,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -106055,11 +106055,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -106077,13 +106077,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -106092,27 +106092,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -106120,11 +106120,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -106134,13 +106134,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -106149,27 +106149,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -106177,11 +106177,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -106263,13 +106263,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi &= -Uint64FromUint64(1) >> Int32FromInt32(12) - uxi |= Uint64FromUint64(1) << Int32FromInt32(52) + uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + uxi = uxi | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -106320,17 +106320,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _7 _7: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi -= Uint64FromUint64(1) << Int32FromInt32(52) - uxi |= Uint64FromInt32(ex) << int32(52) + uxi = uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106461,17 +106461,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106533,12 +106533,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106562,10 +106562,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p1)) & Uint32FromUint32(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p2)) | Uint32FromUint32(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) & Uint32FromUint32(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) | Uint32FromUint32(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106673,13 +106673,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = Float64FromFloat64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = Float64FromFloat64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106754,13 +106754,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float64FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint32(4) == uint32(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106823,8 +106823,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106875,7 +106875,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint32(4) == uint32(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106897,8 +106897,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106994,7 +106994,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -107150,7 +107150,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -107258,7 +107258,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -107338,7 +107338,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107483,7 +107483,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107591,7 +107591,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107682,7 +107682,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107829,7 +107829,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107936,7 +107936,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -108018,7 +108018,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -108160,7 +108160,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -108267,7 +108267,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -108307,7 +108307,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108321,14 +108321,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -108371,7 +108371,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -108395,12 +108395,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -108413,8 +108413,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108429,7 +108429,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108454,7 +108454,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108467,14 +108467,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108501,15 +108501,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108575,7 +108575,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108585,11 +108585,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108603,7 +108603,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108614,14 +108614,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108635,7 +108635,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108658,12 +108658,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108675,8 +108675,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108691,7 +108691,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108716,7 +108716,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108729,14 +108729,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108762,13 +108762,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108805,7 +108805,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108814,11 +108814,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108927,8 +108927,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -109034,7 +109034,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + Tdouble_t(z*(_a2+Tdouble_t(z*(_a4+Tdouble_t(z*(_a6+Tdouble_t(z*(_a8+Tdouble_t(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + Tdouble_t(z*(_a3+Tdouble_t(z*(_a5+Tdouble_t(z*(_a7+Tdouble_t(z*(_a9+Tdouble_t(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(Float64FromFloat64(0.5)*y) + r = r + (p - Tdouble_t(Float64FromFloat64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -109042,11 +109042,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = float64(_t1) + Tdouble_t(w*(_t4+Tdouble_t(w*(float64(_t7)+Tdouble_t(w*(_t10+Tdouble_t(w*float64(_t13)))))))) p3 = _t2 + Tdouble_t(w*(float64(_t5)+Tdouble_t(w*(_t8+Tdouble_t(w*(float64(_t11)+Tdouble_t(w*_t14))))))) p = Tdouble_t(z*p1) - (float64(_tt) - Tdouble_t(w*(p2+Tdouble_t(y*p3)))) - r += float64(_tf) + p + r = r + (float64(_tf) + p) case int32(2): p1 = Tdouble_t(y * (float64(_u0) + Tdouble_t(y*(_u1+Tdouble_t(y*(_u2+Tdouble_t(y*(_u3+Tdouble_t(y*(_u4+Tdouble_t(y*_u5))))))))))) p2 = Float64FromFloat64(1) + Tdouble_t(y*(_v1+Tdouble_t(y*(_v2+Tdouble_t(y*(_v3+Tdouble_t(y*(_v4+Tdouble_t(y*_v5))))))))) - r += Tdouble_t(float64(-Float64FromFloat64(0.5))*y) + p1/p2 + r = r + (Tdouble_t(float64(-Float64FromFloat64(0.5))*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -109058,20 +109058,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = Float64FromFloat64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float64FromFloat64(6) /* FALLTHRU */ + z = z * (y + Float64FromFloat64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float64FromFloat64(5) /* FALLTHRU */ + z = z * (y + Float64FromFloat64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float64FromFloat64(4) /* FALLTHRU */ + z = z * (y + Float64FromFloat64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float64FromFloat64(3) /* FALLTHRU */ + z = z * (y + Float64FromFloat64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float64FromFloat64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + Float64FromFloat64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -109185,7 +109185,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= Float64FromFloat64(3.141592653589793) + y = y * Float64FromFloat64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -109291,7 +109291,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -109299,11 +109299,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -109315,20 +109315,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109456,9 +109456,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109484,31 +109484,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(Tdouble_t(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109614,8 +109614,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109810,7 +109810,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109820,7 +109820,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109910,7 +109910,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109920,7 +109920,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = float64(v1) - c /= float64(*(*float32)(unsafe.Pointer(bp))) + c = c / float64(*(*float32)(unsafe.Pointer(bp))) } else { c = Float64FromInt32(0) } @@ -109967,11 +109967,11 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { } var hi, invc, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, y1, z Tdouble_t var i, k int32 - var ix, iz, tmp, v12, v6 Tuint64_t + var ix, iz, tmp, v6 Tuint64_t var top Tuint32_t - var y, v1, v10, v11, v13, v14, v2, v3, v4, v7, v8 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5, v6 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109987,8 +109987,8 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - v7 = r - v6 = *(*Tuint64_t)(unsafe.Pointer(&v7)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) + v1 = r + v6 = *(*Tuint64_t)(unsafe.Pointer(&v1)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) rhi = *(*float64)(unsafe.Pointer(&v6)) rlo = r - rhi hi = Tdouble_t(rhi * X__log2_data.Finvln2hi) @@ -109998,31 +109998,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+Tdouble_t(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+Tdouble_t(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v10 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v11 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v11)) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix - Uint64FromUint64(52)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110787,9 +110787,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110846,8 +110846,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110861,7 +110861,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110890,32 +110890,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -111053,12 +111053,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -111145,16 +111145,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -111224,11 +111224,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, lhi, llo, x2, yhi, ylo, v7 Tdouble_t var ix, iy, v16, v17 Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v18, v2, v3, v5, v6, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v16, v17, v2, v4, v7 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -111247,19 +111247,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -111273,10 +111273,10 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = float64(Float64FromInt32(1) / x2) - v8 = y + v1 = y goto _9 _9: - v7 = v8 + v7 = v1 } else { v7 = x2 } @@ -111292,51 +111292,51 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix & uint64(0x7fffffffffffffff) + ix = ix - Uint64FromUint64(52)<> Int32FromInt32(12) - uxi |= Uint64FromUint64(1) << Int32FromInt32(52) + uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + uxi = uxi | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111764,8 +111764,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _7 _7: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111773,10 +111773,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint64FromUint64(1) << Int32FromInt32(52) - uxi |= Uint64FromInt32(ex) << int32(52) + uxi = uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111784,10 +111784,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111871,13 +111871,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111935,8 +111935,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111944,10 +111944,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111955,10 +111955,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -112233,13 +112233,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -112255,10 +112255,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -112284,13 +112284,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -112306,10 +112306,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -112381,11 +112381,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= Float64FromFloat64(8.98846567431158e+307) - n -= int32(1023) + y = y * Float64FromFloat64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= Float64FromFloat64(8.98846567431158e+307) - n -= int32(1023) + y = y * Float64FromFloat64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -112394,11 +112394,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -112425,22 +112425,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = float64(x) if n > int32(127) { - y *= Float64FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float64FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float64FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float64FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112486,12 +112486,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112506,18 +112506,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112549,14 +112549,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112572,18 +112572,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112596,9 +112596,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112644,13 +112644,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112666,18 +112666,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112708,11 +112708,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112728,24 +112728,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112806,13 +112806,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112826,18 +112826,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112868,11 +112868,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -113042,9 +113042,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -113063,7 +113063,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -113072,7 +113072,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -113100,9 +113100,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -113212,7 +113212,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -113247,9 +113247,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -113259,13 +113259,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -113291,11 +113291,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -113310,18 +113310,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -113357,13 +113357,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -113377,18 +113377,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113405,28 +113405,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113624,8 +113624,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113725,7 +113725,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113738,7 +113738,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113808,7 +113808,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113821,10 +113821,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113835,7 +113835,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*float64(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*float64(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(Float64FromFloat64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113982,12 +113982,12 @@ func Xa64l(tls *TLS, s uintptr) (r int32) { if !(d != 0) { break } - x |= Uint32FromInt32(int32(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt32(int32(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*int8)(unsafe.Pointer(p)) = 0 return uintptr(unsafe.Pointer(&_s)) @@ -114038,7 +114038,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('/')) { @@ -114047,7 +114047,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -114081,7 +114081,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -114093,7 +114093,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -114105,7 +114105,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*int8)(unsafe.Pointer(s + uintptr(i+uint32(1)))) = 0 return s @@ -114199,7 +114199,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint32(0) for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -114214,11 +114214,11 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -114311,17 +114311,17 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114600,11 +114600,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*4)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114656,7 +114656,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*4)) = tmp } @@ -114685,7 +114685,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114702,7 +114702,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114710,9 +114710,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114727,11 +114727,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname opt = start if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114742,11 +114742,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int32(arg)-int32(start) == Xmblen(tls, start, uint32(MB_LEN_MAX)) { l = int32(arg) - int32(start) @@ -114763,22 +114763,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval @@ -114804,7 +114804,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114820,13 +114820,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 704 + v5 = __ccgo_ts + 704 } else { - v6 = __ccgo_ts + 611 + v5 = __ccgo_ts + 611 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114887,9 +114887,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint32 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_prlimit64), int32(Int32FromInt32(0)), resource, int32(Int32FromInt32(0)), int32(rlim)))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114912,11 +114912,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)] == -Uint32FromUint32(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) + v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114968,7 +114968,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114993,7 +114993,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -115281,15 +115281,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint32FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint32(8) } else { v2 = uint32(UintptrFromInt32(0) + 4) } align = Int32FromUint32(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint32(8)) *(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*int64)(unsafe.Pointer(bp))) @@ -115299,12 +115299,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = int64(*(*int32)(unsafe.Pointer(bp + 8))) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint32(8)) } - new_offset = int32(uint32(new_offset) + Uint32FromInt64(8)) - old_offset = int32(uint32(old_offset) + Uint32FromInt64(4)) + new_offset = Int32FromUint32(uint32(new_offset) + Uint32FromInt64(8)) + old_offset = Int32FromUint32(uint32(old_offset) + Uint32FromInt64(4)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint32FromInt32(old_size-old_offset)) @@ -115352,7 +115352,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -115495,28 +115495,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*int8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*int8)(unsafe.Pointer(v3)) = *(*int8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115526,29 +115526,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*int8)(unsafe.Pointer(v7)) = Int8FromUint8(cval) + v1 = dest + dest = dest + 1 + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*int8)(unsafe.Pointer(v8)) = *(*int8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } } *(*int8)(unsafe.Pointer(dest)) = 0 @@ -115597,7 +115597,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+740, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+16, mnt+20)) } @@ -115655,15 +115655,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(192) defer tls.Free(192) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint32 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+176 */ TFTW var _ /* new at bp+144 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint32(1))))) == int32('/') { v1 = l - uint32(1) @@ -115715,11 +115715,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint32(j + uint32(1)) (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel if h != 0 { @@ -115733,7 +115733,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint32(1))))) != int32('/')) { @@ -115742,7 +115742,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint32(k) } @@ -115757,10 +115757,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115798,9 +115798,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115812,11 +115812,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115989,7 +115989,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(s0)) } @@ -116002,12 +116002,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]int8 var _ /* stack at bp+0 */ [4097]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint32(0) nup = uint32(0) check_dir = 0 @@ -116042,27 +116042,27 @@ _3: nup = uint32(0) q = uint32(0) v4 = q - q++ + q = q + 1 (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') - p++ + p = p + 1 /* Initial // is special. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint32(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v5] = int8('/') + v4 = q + q = q + 1 + (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint32FromInt32(int32(z) - int32(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint32FromInt32(int32(z) - int32(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint32(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -116072,17 +116072,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v7] = int8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + l = l + 1 } if q+l >= uint32(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 - p += l + p = p + l up = 0 if l0 == uint32(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint32(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint32(1)]) == int32('.') { up = int32(1) @@ -116091,8 +116091,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint32(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -116121,23 +116121,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint32(1) && (q > uint32(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint32(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint32(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -116145,10 +116145,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int32(1)]) == int32('/') { for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint32FromInt32(k) + p = p - Uint32FromInt32(k) Xmemmove(tls, bp+uintptr(p), bp, Uint32FromInt32(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -116156,7 +116156,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -116170,26 +116170,26 @@ _1: /* Cancel any initial .. components. */ p = uint32(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint32(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint32(1) { - l-- + l = l - 1 } - p += uint32(2) + p = p + uint32(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]int8)(unsafe.Pointer(bp)))[v11] = int8('/') + v4 = l + l = l + 1 + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') } if l+(q-p)+uint32(1) >= uint32(PATH_MAX) { goto toolong @@ -116710,19 +116710,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1168) defer tls.Free(1168) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+68 */ [1024]int8 var _ /* hlen at bp+1092 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116740,12 +116740,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint32FromInt32(l2) >= uint32(1024)-Uint32FromInt32(l) { l = Int32FromUint32(Uint32FromInt64(1024) - Uint32FromInt32(1)) } else { - l += l2 + l = l + l2 } if int32((*(*[1024]int8)(unsafe.Pointer(bp + 68)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]int8)(unsafe.Pointer(bp + 68)))[v2] = int8('\n') + v1 = l + l = l + 1 + (*(*[1024]int8)(unsafe.Pointer(bp + 68)))[v1] = int8('\n') } if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+564, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116998,7 +116998,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -117243,11 +117243,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -117286,9 +117286,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -117297,10 +117297,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -117462,12 +117462,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = int32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + wn = wn - 1 goto _4 _4: } @@ -117482,44 +117482,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint32(4) + s = s + uintptr(4) + wn = wn - uint32(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117539,76 +117539,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { for wn >= uint32(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint32(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint32(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint32(1) } @@ -117757,31 +117757,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*int8)(unsafe.Pointer(v7)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint32(4) } @@ -117827,16 +117827,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117852,9 +117852,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]int8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint32(0) @@ -117868,9 +117868,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117890,13 +117890,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117915,13 +117915,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -119127,9 +119127,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -119140,8 +119140,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -119153,20 +119153,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -119179,34 +119179,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -119220,17 +119220,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint32(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint32(253) || space <= 0 { return -int32(1) @@ -119281,22 +119281,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -119318,9 +119318,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -119356,26 +119356,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*int8)(unsafe.Pointer(v3)) = int8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if j >= int32(end)-int32(p) || j >= int32(dend)-int32(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) } } else { *(*int8)(unsafe.Pointer(dest)) = 0 @@ -119388,7 +119388,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -119423,7 +119423,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int32(end)-int32(p) < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119533,9 +119533,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119547,31 +119547,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if len1+int32(10) > int32(r+uintptr(rlen))-int32(p) { return -int32(1) @@ -119579,7 +119579,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119921,7 +119921,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119933,7 +119933,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if int32(*(*int8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119973,11 +119973,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 891 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -120020,9 +120020,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint32(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -120031,15 +120031,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint32(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 68 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*68 ___lock(tls, b+60) - p2 = b + 66 - *(*int16)(unsafe.Pointer(p2)) = int16(uint32(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 66 + *(*int16)(unsafe.Pointer(v2)) = int16(uint32(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+60) @@ -120056,7 +120056,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -120068,16 +120068,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -120180,7 +120180,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -120250,13 +120250,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -120387,7 +120387,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint32(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint32(1) + size = size + (size + uint32(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120452,15 +120452,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint32FromInt32(5)*Uint32FromInt64(4)-Uint32FromInt32(i)+l { return int32(ERANGE) } - buf += uintptr(uint32(4) - Uint32FromInt32(i)) - buflen -= Uint32FromInt32(5)*Uint32FromInt64(4) - Uint32FromInt32(i) + l + buf = buf + uintptr(uint32(4)-Uint32FromInt32(i)) + buflen = buflen - (Uint32FromInt32(5)*Uint32FromInt64(4) - Uint32FromInt32(i) + l) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint32FromInt32(2) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint32FromInt32(2) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) @@ -120510,7 +120510,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint32(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint32(1) + size = size + (size + uint32(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120569,41 +120569,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint32(buf) & (Uint32FromInt64(4) - Uint32FromInt32(1)) need = Uint32FromInt32(4) * Uint32FromInt64(4) - need += Uint32FromInt32(cnt+Int32FromInt32(1)) * (uint32(4) + Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint32(1) - need += Xstrlen(tls, bp+1344) + uint32(1) - need += align + need = need + Uint32FromInt32(cnt+Int32FromInt32(1))*(uint32(4)+Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint32(1)) + need = need + (Xstrlen(tls, bp+1344) + uint32(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint32FromInt32(3) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint32FromInt32(cnt+Int32FromInt32(1)) * uint32(4)) + buf = buf + uintptr(Uint32FromInt32(cnt+Int32FromInt32(1))*uint32(4)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint32(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint32(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4))) + uint32(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) } @@ -120864,7 +120864,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint32FromInt32(i)) if Uint32FromInt32(i) < uint32(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint32(16), 0) @@ -121045,17 +121045,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint32FromInt32(3) * Uint32FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -121068,29 +121068,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8('.') - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+922) } @@ -121100,15 +121100,15 @@ var _xdigits = [17]int8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', ' func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1728) defer tls.Free(1728) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1588 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+931, bp+1588, bp+512, uint32(1032)) if !(f != 0) { return @@ -121123,7 +121123,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -121141,14 +121141,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -121161,35 +121161,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*int8)(unsafe.Pointer(p)) != 0; v13 { - v10 = int32(*(*int8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*int8)(unsafe.Pointer(z)) != 0; v18 { - v15 = int32(*(*int8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if int32(z)-int32(p) < int32(256) { @@ -121203,7 +121203,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1312) defer tls.Free(1312) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint32 var v4, v5 int32 var v7 bool @@ -121211,7 +121211,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1164 */ TFILE var _ /* line at bp+0 */ [128]int8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+955, bp+1164, bp+132, uint32(1032)) if !(f != 0) { return @@ -121221,7 +121221,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -121239,14 +121239,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint32FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -121346,7 +121346,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = int8('%') Xstrcat(tls, bp+78, p) @@ -121474,7 +121474,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint32FromInt32(2)*Uint32FromInt64(4)+Uint32FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121576,11 +121576,11 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(160) defer tls.Free(160) - var r, r1, v1, v10, v12, v13, v14, v2, v21, v23, v24, v25, v3, v32 int32 + var r, r1, v1, v10, v2, v3 int32 var tv uintptr - var v15, v16, v17, v18, v19, v20, v26, v27, v28, v29, v30, v31, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t var _ /* tv32 at bp+152 */ [2]int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_getsockopt) v2 = int32(__SC_getsockopt) v3 = 0 @@ -121646,49 +121646,49 @@ _11: *(*[1]Tsocklen_t)(unsafe.Pointer(bp + 48)) = [1]Tsocklen_t{ 0: uint32(8), } - v12 = int32(SYS_getsockopt) - v13 = int32(__SC_getsockopt) - v14 = 0 - v15 = fd - v16 = level - v17 = optname - v18 = int32(bp + 152) - v19 = int32(bp + 48) - v20 = int32(Int32FromInt32(0)) - if v14 != 0 { - r = ___syscall_cp(tls, v12, v15, v16, v17, v18, v19, v20) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = fd + v5 = level + v6 = optname + v7 = int32(bp + 152) + v8 = int32(bp + 48) + v9 = int32(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, v12, v15, v16, v17, v18, v19, v20) + r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } if r != int32(-Int32FromInt32(ENOSYS)) { - v21 = r + v10 = r goto _22 } - if v14 != 0 { + if v3 != 0 { *(*[6]int32)(unsafe.Pointer(bp + 100)) = [6]int32{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int32(SYS_socketcall), v13, int32(bp+100), 0, 0, 0, 0) + r = ___syscall_cp(tls, int32(SYS_socketcall), v2, int32(bp+100), 0, 0, 0, 0) } else { *(*[6]int32)(unsafe.Pointer(bp + 124)) = [6]int32{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int32(SYS_socketcall), v13, int32(bp+124)) + r = X__syscall2(tls, int32(SYS_socketcall), v2, int32(bp+124)) } - v21 = r + v10 = r goto _22 _22: - r1 = v21 + r1 = v10 if r1 < 0 { break } @@ -121708,49 +121708,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v23 = int32(SYS_getsockopt) - v24 = int32(__SC_getsockopt) - v25 = 0 - v26 = fd - v27 = level - v28 = optname - v29 = int32(optval) - v30 = int32(optlen) - v31 = int32(Int32FromInt32(0)) - if v25 != 0 { - r = ___syscall_cp(tls, v23, v26, v27, v28, v29, v30, v31) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = fd + v5 = level + v6 = optname + v7 = int32(optval) + v8 = int32(optlen) + v9 = int32(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, v23, v26, v27, v28, v29, v30, v31) + r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } if r != int32(-Int32FromInt32(ENOSYS)) { - v32 = r + v10 = r goto _33 } - if v25 != 0 { + if v3 != 0 { *(*[6]int32)(unsafe.Pointer(bp + 100)) = [6]int32{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int32(SYS_socketcall), v24, int32(bp+100), 0, 0, 0, 0) + r = ___syscall_cp(tls, int32(SYS_socketcall), v2, int32(bp+100), 0, 0, 0, 0) } else { *(*[6]int32)(unsafe.Pointer(bp + 124)) = [6]int32{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int32(SYS_socketcall), v24, int32(bp+124)) + r = X__syscall2(tls, int32(SYS_socketcall), v2, int32(bp+124)) } - v32 = r + v10 = r goto _33 _33: - r1 = v32 + r1 = v10 break } } @@ -121800,7 +121800,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -121812,16 +121812,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121992,7 +121992,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -122038,14 +122038,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint32((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = 0 goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 8 } @@ -122067,9 +122067,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(48) defer tls.Free(48) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -122079,11 +122079,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+40, bp)) X__syscall1(tls, int32(SYS_close), fd) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -122131,7 +122131,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -122161,7 +122161,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -122188,12 +122188,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Int8FromUint8(':') @@ -122320,7 +122320,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -122334,11 +122334,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -122359,7 +122359,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -122371,11 +122371,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -122385,7 +122385,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { @@ -122396,9 +122396,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*int8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*int8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -122406,22 +122406,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -122438,15 +122438,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint32FromInt32(int32(2)*(i+int32(1)-brk))) @@ -122459,7 +122459,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -122467,16 +122467,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -122578,7 +122578,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint32(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+84, int32(10)) @@ -122628,14 +122628,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122643,23 +122643,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122668,9 +122668,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122688,14 +122688,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1680) defer tls.Free(1680) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122718,15 +122718,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122745,7 +122745,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122753,26 +122753,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*int8)(unsafe.Pointer(p)) != 0; v17 { - v14 = int32(*(*int8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*int8)(unsafe.Pointer(v18)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122784,35 +122784,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*int8)(unsafe.Pointer(p)) != 0; v23 { - v20 = int32(*(*int8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*int8)(unsafe.Pointer(z)) != 0; v28 { - v25 = int32(*(*int8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if _is_valid_hostname(tls, p) != 0 { @@ -122822,11 +122822,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122873,7 +122873,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 8 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint32FromInt32(len1)) return 0 } @@ -122918,14 +122918,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10176, bp+10168, bp+10184, int32(4800), conf) < 0 { return -int32(11) @@ -122947,7 +122947,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122962,7 +122962,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt @@ -122987,13 +122987,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]int8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint32(256)) < 0 { return -int32(1) } @@ -123007,19 +123007,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= (*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { *(*int8)(unsafe.Pointer(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { return -int32(2) @@ -123050,23 +123050,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v9 = int32(*(*int8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -123152,7 +123152,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -123188,7 +123188,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -123208,7 +123208,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -123218,7 +123218,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*int8)(unsafe.Pointer(canon)) = 0 if name != 0 { @@ -123236,7 +123236,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -123270,7 +123270,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -123279,18 +123279,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -123308,7 +123308,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -123327,7 +123327,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -123381,31 +123381,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint32(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -123552,19 +123552,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*int8)(unsafe.Pointer(p)) != 0; v19 { - v16 = int32(*(*int8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint32(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -123576,9 +123576,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -123586,18 +123586,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123760,34 +123760,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123802,21 +123802,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123829,14 +123829,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123863,7 +123863,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123874,18 +123874,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32(eom)-int32(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ) > int32(eom)-int32(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if r > int32(eom)-int32(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(p) - int32(ptr) @@ -123902,8 +123902,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123938,22 +123938,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 44 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 44 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 44 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4)) - p4 = handle + 44 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4)) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int32FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123964,7 +123964,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -124087,7 +124087,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint32(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint32FromInt32(2))) + _idx = Int32FromUint32(uint32(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint32FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -124193,13 +124193,13 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti } bp := tls.Alloc(32) defer tls.Free(32) - var csize, v3, v6 uintptr + var csize, v3 uintptr var i, i1, ns, r, v2 int32 var s Ttime_t var v1 int64 var v4 t__predefined_size_t var v7 uint64 - _, _, _, _, _, _, _, _, _, _, _, _ = csize, i, i1, ns, r, s, v1, v2, v3, v4, v6, v7 + _, _, _, _, _, _, _, _, _, _, _ = csize, i, i1, ns, r, s, v1, v2, v3, v4, v7 defer func() { Xrealloc(tls, csize, 0) }() if timeout != 0 { v1 = (*Ttimespec)(unsafe.Pointer(timeout)).Ftv_sec @@ -124240,7 +124240,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _5 _5: ; - i++ + i = i + 1 } if timeout != 0 { if !((Uint64FromInt64(s)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) { @@ -124252,11 +124252,11 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti 0: int32(Int32FromUint64(v7)), 1: ns, } - v6 = bp + 16 + v3 = bp + 16 } else { - v6 = uintptr(0) + v3 = uintptr(0) } - r = int32(___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v6), 0)) + r = int32(___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v3), 0)) i1 = 0 for { if !(i1 < r) { @@ -124266,7 +124266,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _8 _8: ; - i1++ + i1 = i1 + 1 } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -124277,11 +124277,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int32 var _ /* tvts at bp+4 */ [2]int64 - _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v7 + _, _, _, _ = cmsg, last, type1, v2 if false { return } @@ -124333,11 +124333,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v2 = cmsg + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -124348,11 +124348,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } *(*Tsocklen_t)(unsafe.Pointer(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { - v7 = uintptr(0) + v2 = uintptr(0) } else { - v7 = last + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v2 = last + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } - cmsg = v7 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + Uint32FromInt64(16) @@ -124443,7 +124443,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint32(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { return -int32(1) @@ -124471,7 +124471,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -124614,7 +124614,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -124682,9 +124682,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 8 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -124704,7 +124704,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(272) defer tls.Free(272) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint32 @@ -124725,7 +124725,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124795,7 +124795,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124809,7 +124809,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) @@ -124843,7 +124843,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124870,7 +124870,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124898,7 +124898,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124920,13 +124920,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124965,7 +124965,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124979,7 +124979,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124996,10 +124996,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) } fallthrough @@ -125017,7 +125017,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) @@ -125076,7 +125076,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -125128,7 +125128,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -125151,7 +125151,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -125181,9 +125181,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 4)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 8)) = _answer *(*int32)(unsafe.Pointer(bp + 12)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+16 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 12)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), bp+16, int32(512)) if r >= 0 { @@ -125198,11 +125198,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, *(*int32)(unsafe.Pointer(bp + 12))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 12)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = *(*int32)(unsafe.Pointer(bp + 12)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -125232,16 +125232,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(656) defer tls.Free(656) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint32 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint32 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]int8 var _ /* z at bp+648 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -125278,7 +125278,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1089) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+648, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { if x > uint32(15) { @@ -125291,103 +125291,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1096) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+648, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { if x1 > uint32(10) { - v6 = uint32(10) + v5 = uint32(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = v6 + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = v5 } } p = Xstrstr(tls, bp, __ccgo_ts+1106) if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+648, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 648)) != p { if x2 > uint32(60) { - v7 = uint32(60) + v5 = uint32(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = v7 + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = v5 } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v11 { - v8 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = int32(*(*int8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 648)) = p for { - if v20 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648)))) != 0; v20 { - v17 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648)))) != 0; v4 { + v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 648))++ + *(*uintptr)(unsafe.Pointer(bp + 648)) = *(*uintptr)(unsafe.Pointer(bp + 648)) + 1 } *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 648)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v24 { - v21 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = int32(*(*int8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -125561,13 +125561,13 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(160) defer tls.Free(160) - var r, r1, v1, v10, v13, v14, v15, v2, v22, v24, v25, v26, v3, v33 int32 + var r, r1, v1, v10, v2, v3 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v12 uint64 - var v16, v17, v18, v19, v20, v21, v27, v28, v29, v30, v31, v32, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9 + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_setsockopt) v2 = int32(__SC_setsockopt) v3 = 0 @@ -125645,49 +125645,49 @@ _11: 0: int32(s), 1: int32(Int32FromUint64(v12)), } - v13 = int32(SYS_setsockopt) - v14 = int32(__SC_setsockopt) - v15 = 0 - v16 = fd - v17 = level - v18 = optname - v19 = int32(bp + 48) - v20 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) - v21 = int32(Int32FromInt32(0)) - if v15 != 0 { - r = ___syscall_cp(tls, v13, v16, v17, v18, v19, v20, v21) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = fd + v5 = level + v6 = optname + v7 = int32(bp + 48) + v8 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) + v9 = int32(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, v13, v16, v17, v18, v19, v20, v21) + r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } if r != int32(-Int32FromInt32(ENOSYS)) { - v22 = r + v10 = r goto _23 } - if v15 != 0 { + if v3 != 0 { *(*[6]int32)(unsafe.Pointer(bp + 104)) = [6]int32{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int32(SYS_socketcall), v14, int32(bp+104), 0, 0, 0, 0) + r = ___syscall_cp(tls, int32(SYS_socketcall), v2, int32(bp+104), 0, 0, 0, 0) } else { *(*[6]int32)(unsafe.Pointer(bp + 128)) = [6]int32{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int32(SYS_socketcall), v14, int32(bp+128)) + r = X__syscall2(tls, int32(SYS_socketcall), v2, int32(bp+128)) } - v22 = r + v10 = r goto _23 _23: - r1 = v22 + r1 = v10 case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -125700,49 +125700,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v24 = int32(SYS_setsockopt) - v25 = int32(__SC_setsockopt) - v26 = 0 - v27 = fd - v28 = level - v29 = optname - v30 = int32(optval) - v31 = Int32FromUint32(optlen) - v32 = int32(Int32FromInt32(0)) - if v26 != 0 { - r = ___syscall_cp(tls, v24, v27, v28, v29, v30, v31, v32) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = fd + v5 = level + v6 = optname + v7 = int32(optval) + v8 = Int32FromUint32(optlen) + v9 = int32(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, v1, v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, v24, v27, v28, v29, v30, v31, v32) + r = X__syscall6(tls, v1, v4, v5, v6, v7, v8, v9) } if r != int32(-Int32FromInt32(ENOSYS)) { - v33 = r + v10 = r goto _34 } - if v26 != 0 { + if v3 != 0 { *(*[6]int32)(unsafe.Pointer(bp + 104)) = [6]int32{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int32(SYS_socketcall), v25, int32(bp+104), 0, 0, 0, 0) + r = ___syscall_cp(tls, int32(SYS_socketcall), v2, int32(bp+104), 0, 0, 0, 0) } else { *(*[6]int32)(unsafe.Pointer(bp + 128)) = [6]int32{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int32(SYS_socketcall), v25, int32(bp+128)) + r = X__syscall2(tls, int32(SYS_socketcall), v2, int32(bp+128)) } - v33 = r + v10 = r goto _34 _34: - r1 = v33 + r1 = v10 break } } @@ -126135,18 +126135,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126161,14 +126161,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]int8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -126190,11 +126190,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint32(0) grlist_len = uint32(0) @@ -126234,11 +126234,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint32(4), uint32(1), f) < uint32(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -126252,12 +126252,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += *(*Tuint32_t)(unsafe.Pointer(bp + 44)) - grlist_len += *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + len1 = len1 + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + grlist_len = grlist_len + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -126270,11 +126270,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -126299,14 +126299,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*4)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -126368,9 +126368,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint32(16) - uint32(buf)) % uint32(16)) + buf = buf + uintptr((uint32(16)-uint32(buf))%uint32(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12)) + uint32(1)) * uint32(4)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -126383,7 +126383,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) } @@ -126500,7 +126500,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126512,13 +126512,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+4 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) for { @@ -126539,32 +126539,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126576,12 +126576,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint32(4), *(*Tsize_t)(unsafe.Pointer(nmem))+uint32(1)) @@ -126601,21 +126601,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*4)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -126638,10 +126638,10 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(64) defer tls.Free(64) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t - var nlim, ret, rv, v14, v6 int32 + var nlim, ret, rv, v6 int32 var v3, v4 Tuint32_t var _ /* buf at bp+36 */ uintptr var _ /* gr at bp+0 */ Tgroup @@ -126651,7 +126651,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+24 */ [3]Tint32_t var _ /* size at bp+48 */ Tsize_t var _ /* swap at bp+20 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v3, v4, v6, v9 ret = -int32(1) n = int32(1) *(*int32)(unsafe.Pointer(bp + 20)) = 0 @@ -126695,7 +126695,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -126723,7 +126723,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -126734,17 +126734,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*4)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= nlim { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -126759,26 +126759,26 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= nlim { - v13 = groups + n = n + 1 + v9 = n + if v9 <= nlim { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > nlim { - v14 = -int32(1) + v6 = -int32(1) } else { - v14 = n + v6 = n } - ret = v14 + ret = v6 *(*int32)(unsafe.Pointer(ngroups)) = n goto cleanup cleanup: @@ -126793,18 +126793,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126819,11 +126819,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]int8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -126845,11 +126845,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint32(0) *(*[11]int8)(unsafe.Pointer(bp + 44)) = [11]int8{} @@ -126901,11 +126901,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -127069,7 +127069,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -127083,10 +127083,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+4 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) for { @@ -127107,57 +127107,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v10)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v14)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -127225,10 +127225,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+28 */ Tmsghdr var _ /* req_buf at bp+16 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 16)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -127314,7 +127314,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -127329,15 +127329,15 @@ retry: if !(i < len1/uint32(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -127739,7 +127739,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -127809,9 +127809,9 @@ func Xrandom(tls *TLS) (r int32) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - var k, v2, v3 int32 + var k, v2 int32 var v1 Tuint32_t - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -127821,14 +127821,14 @@ func Xrandom(tls *TLS) (r int32) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127884,7 +127884,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127900,7 +127900,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*4)) = UintptrFromInt32(0) _ = ap @@ -127928,7 +127928,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127944,7 +127944,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127972,7 +127972,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127988,7 +127988,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*4)) = UintptrFromInt32(0) _ = ap @@ -128018,11 +128018,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1276) seen_eacces = 0 @@ -128049,7 +128049,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint32FromInt32(int32(z)-int32(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } @@ -128069,9 +128069,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -128554,7 +128554,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint32(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -128562,12 +128562,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint32(1) if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -128576,12 +128576,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint32(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('=')) { z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) - k += uint32(2) + k = k + uint32(2) if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint32(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -128590,7 +128590,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) @@ -128643,22 +128643,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -128676,15 +128676,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = int32(*(*int8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int32(p-uintptr(1))-int32(p0) < int32(16) { Xmemcpy(tls, bp+8, p0, Uint32FromInt32(int32(p-uintptr(1))-int32(p0))) @@ -128702,7 +128702,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -128710,7 +128710,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -128718,13 +128718,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+4 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint32(0) if flags&int32(FNM_PERIOD) != 0 { if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { @@ -128738,26 +128738,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+4) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 4)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 4)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128767,8 +128767,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -128793,13 +128793,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint32(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128819,18 +128819,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v10))))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128838,7 +128838,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -128848,22 +128848,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128885,7 +128885,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128897,11 +128897,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128911,7 +128911,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) goto _14 _14: } @@ -128922,9 +128922,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) < 0) { break @@ -128932,7 +128932,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128960,7 +128960,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128972,7 +128972,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -129004,7 +129004,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -129059,13 +129059,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(144) defer tls.Free(144) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep int8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -129077,9 +129077,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint32(1) < uint32(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -129096,8 +129096,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint32FromInt32(j) + pat = pat + uintptr(i) + pos = pos + Uint32FromInt32(j) v4 = Int32FromInt32(0) j = v4 i = v4 @@ -129117,7 +129117,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int32(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -129126,9 +129126,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int32(1)) + pat = pat + uintptr(i+int32(1)) i = -int32(1) - pos += Uint32FromInt32(j + int32(1)) + pos = pos + Uint32FromInt32(j+int32(1)) j = -int32(1) } /* Only store a character if it fits in the buffer, but if @@ -129137,9 +129137,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint32FromInt32(j+Int32FromInt32(1)) < uint32(PATH_MAX) { - v5 = j - j++ - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v5)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -129153,7 +129153,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 if !(*(*int8)(unsafe.Pointer(pat)) != 0) { @@ -129188,19 +129188,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int32(p2)-int32(p))%int32(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = int8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 483 + v2 = __ccgo_ts + 483 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -129210,9 +129210,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -129250,11 +129250,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*int8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -129300,13 +129300,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) - var delim, v1, v12 int8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 int8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+28 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint32(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -129314,16 +129314,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*int8)(unsafe.Pointer(v2)) = 0 } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*int8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1310) + v2 = Xgetenv(tls, __ccgo_ts+1310) } - home = v3 + home = v2 if !(home != 0) { if *(*int8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint32(PATH_MAX), bp+28) @@ -129358,20 +129358,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) } if *(*int8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v13))) = 0 + v1 = delim + *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -129445,7 +129445,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -129453,7 +129453,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+4, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -129467,7 +129467,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint32(1))*uint32(4)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -129483,7 +129483,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint32(0) @@ -129497,7 +129497,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -129522,7 +129522,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint32(0) @@ -129918,7 +129918,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129960,7 +129960,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*4)) } @@ -129970,7 +129970,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*4)) } @@ -130068,7 +130068,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -130106,16 +130106,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 8 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*4 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint32(20)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -130128,8 +130128,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -130140,16 +130140,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -130160,11 +130160,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -130213,11 +130213,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]int8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint32(0) @@ -130242,7 +130242,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if int32(*(*int8)(unsafe.Pointer(s))) == int32('[') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*int8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -130257,21 +130257,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || int32(*(*int8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint32FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -130279,7 +130279,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -130287,9 +130287,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*4)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*4)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130322,11 +130322,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(288) defer tls.Free(288) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+16 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -130339,7 +130339,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+16) if err != REG_OK { @@ -130398,11 +130398,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -130421,13 +130421,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -130440,7 +130440,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -130467,12 +130467,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -130486,7 +130486,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -130509,7 +130509,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -130535,11 +130535,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('['): @@ -130581,7 +130581,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch int32(*(*int8)(unsafe.Pointer(v14))) { case 0: @@ -130595,12 +130595,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -130615,20 +130615,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 24 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -130644,7 +130644,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -130653,47 +130653,47 @@ _2: if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 24 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 24 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 24 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 24 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -130702,7 +130702,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -130711,7 +130711,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -130755,8 +130755,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -130774,12 +130774,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -130788,7 +130788,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -130796,28 +130796,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -130856,7 +130856,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130880,7 +130880,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130901,24 +130901,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -131059,7 +131059,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -131119,7 +131119,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -131160,7 +131160,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -131173,7 +131173,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -131191,7 +131191,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -131204,7 +131204,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -131223,7 +131223,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -131258,13 +131258,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -131272,8 +131272,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -131308,7 +131308,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -131378,20 +131378,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -131475,26 +131475,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -131508,7 +131508,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -131602,7 +131602,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -131624,13 +131624,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -131685,8 +131685,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131925,7 +131925,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131966,7 +131966,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -132009,7 +132009,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -132026,8 +132026,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -132090,7 +132090,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -132100,7 +132100,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -132110,7 +132110,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint32(32)*Uint32FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -132139,7 +132139,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint32FromInt64(4)*Uint32FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -132154,7 +132154,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -132165,7 +132165,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = new_tags @@ -132173,7 +132173,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -132199,7 +132199,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint32(4)*Uint32FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -132214,7 +132214,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = new_tags @@ -132222,7 +132222,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) return new_set @@ -132236,9 +132236,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -132267,7 +132267,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max @@ -132275,13 +132275,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case -int32(2): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = *(*int32)(unsafe.Pointer(p2)) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max } case -int32(1): default: @@ -132582,9 +132582,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -132638,7 +132638,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint32(4)*Uint32FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -132653,7 +132653,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) } else { @@ -132663,13 +132663,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -132687,7 +132687,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -132708,14 +132708,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -132730,7 +132730,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 32 } p1 += 32 @@ -132913,7 +132913,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 24 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132958,7 +132958,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132968,12 +132968,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, Uint32FromInt32(add)+uint32(1), uint32(32)) if transitions == UintptrFromInt32(0) { @@ -132995,7 +132995,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 32 } initial = Xcalloc(tls, Uint32FromInt32(i)+uint32(1), uint32(32)) @@ -133026,7 +133026,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags != 0) { @@ -133038,7 +133038,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -133101,7 +133101,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -133134,7 +133134,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -133175,11 +133175,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint32(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint32FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -133222,7 +133222,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -133274,13 +133274,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint32 + var v1 uint32 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -133333,44 +133333,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint32(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v2 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v2 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v3 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v3 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v4 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v4 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*8))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*8))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -133381,10 +133381,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 if v7 <= 0 { @@ -133392,10 +133392,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -133418,7 +133418,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -133441,7 +133441,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos @@ -133462,18 +133462,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -133508,7 +133508,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -133557,7 +133557,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -133588,7 +133588,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 8 @@ -133612,7 +133612,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -133693,13 +133693,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -133763,7 +133763,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -133774,12 +133774,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 if v3 <= 0 { @@ -133787,10 +133787,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -133860,7 +133860,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133910,7 +133910,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133941,21 +133941,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int32(1)) - pos += bt_len - int32(1) + str_byte = str_byte + uintptr(bt_len-int32(1)) + pos = pos + (bt_len - int32(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133966,18 +133966,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -134048,7 +134048,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -134076,9 +134076,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*4)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos } } goto _17 @@ -134105,7 +134105,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -134161,8 +134161,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -134185,7 +134185,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -134201,23 +134201,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_eo { - v3 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v3 + v1 = -Int32FromInt32(1) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for i < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = -int32(1) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) - i++ + i = i + 1 } } @@ -134443,7 +134443,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint32(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint32(31)*h + uint32(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -134466,7 +134466,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint32(2) + newsize = newsize * uint32(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint32(8)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -134494,8 +134494,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -134538,8 +134538,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -134595,11 +134595,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 8 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint32(4) { if !(_resize(tls, uint32(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -134678,7 +134678,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint32(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -134710,7 +134710,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -134731,9 +134731,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [49]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -134742,11 +134742,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -134755,9 +134755,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 4 + BoolUintptr(c > 0)*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + BoolUintptr(c > 0)*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) goto _3 _3: @@ -134766,14 +134766,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 4)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 4 + v1 = i + i = i + 1 + a[v1] = n + 4 n = *(*uintptr)(unsafe.Pointer(n + 4)) for *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) != 0 { - v6 = i - i++ - a[v6] = n + 4 + 1*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + 1*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -134783,13 +134783,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134930,17 +134930,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [48]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134950,9 +134950,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 4 + BoolUintptr(c > 0)*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + BoolUintptr(c > 0)*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) goto _2 _2: @@ -134967,15 +134967,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 4)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -135024,9 +135024,9 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 if to != 0 { v1 = (*Ttimespec)(unsafe.Pointer(to)).Ftv_sec } else { @@ -135066,11 +135066,11 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 0: int32(s), 1: ns, } - v5 = bp + 16 + v3 = bp + 16 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v5), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v3), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0))) } func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts uintptr, mask uintptr) (r1 int32) { @@ -135083,10 +135083,10 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 var _ /* data at bp+24 */ [2]Tsyscall_arg_t - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 24)) = [2]Tsyscall_arg_t{ 0: Int32FromUint32(uint32(mask)), 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), @@ -135130,11 +135130,11 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui 0: int32(s), 1: ns, } - v5 = bp + 16 + v3 = bp + 16 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pselect6), n, int32(rfds), int32(wfds), int32(efds), int32(v5), int32(bp+24)))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pselect6), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+24)))) } func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uintptr) (r1 int32) { @@ -135148,9 +135148,9 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin var ns, r int32 var us Tsuseconds_t var v1, v2 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 - _, _, _, _, _, _, _, _, _, _ = max_time, ns, r, s, us, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = max_time, ns, r, s, us, v1, v2, v3, v4 if tv != 0 { v1 = (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec } else { @@ -135172,8 +135172,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int32(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = int32(us * int64(1000)) } r = -int32(ENOSYS) @@ -135206,11 +135206,11 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin 0: int32(s), 1: int32(us), } - v5 = bp + 24 + v3 = bp + 24 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS__newselect), n, int32(rfds), int32(wfds), int32(efds), int32(v5), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS__newselect), n, int32(rfds), int32(wfds), int32(efds), int32(v3), 0))) } var _all_mask = [2]uint32{ @@ -135430,14 +135430,14 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) bp := tls.Alloc(64) defer tls.Free(64) var r, v2 int32 - var v1, v3, v4, v5, v6 uintptr + var v1, v3 uintptr var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+36 */ Tk_sigaction var _ /* u at bp+8 */ struct { Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _ = r, v1, v2, v3, v4, v5, v6 + _, _, _, _ = r, v1, v2, v3 if sa != 0 { if uint32(*(*uintptr)(unsafe.Pointer(sa))) > uint32(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint32FromInt32(sig-Int32FromInt32(1))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 @@ -135484,24 +135484,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint32(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { - v4 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v4 = __ccgo_fp(X__restore) + v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v4 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+12, sa+4, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v5 = bp + 16 + v1 = bp + 16 } else { - v5 = uintptr(0) + v1 = uintptr(0) } if old != 0 { - v6 = bp + 36 + v3 = bp + 36 } else { - v6 = uintptr(0) + v3 = uintptr(0) } - r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v5), int32(v6), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v1), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) @@ -135603,7 +135603,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135681,7 +135681,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -135720,7 +135720,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135835,9 +135835,9 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v4 uintptr + var v3 uintptr var v5 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v5 if ts != 0 { v1 = (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec } else { @@ -135876,11 +135876,11 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) 0: int32(Int32FromUint64(v5)), 1: ns, } - v4 = bp + 16 + v3 = bp + 16 } else { - v4 = uintptr(0) + v3 = uintptr(0) } - return int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v4), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) + return int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) return r1 } @@ -136075,7 +136075,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int32(SYS_statx), fd, int32(path), flag, int32(Int32FromInt32(0x7ff)), int32(bp))) if ret != 0 { return ret @@ -136286,7 +136286,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -136461,9 +136461,9 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r defer tls.Free(64) var i, ns0, ns1, r int32 var s0, s1 Ttime_t - var tv, v1, v2 uintptr + var tv, v1 uintptr var _ /* tmp at bp+48 */ [4]int32 - _, _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1, v2 + _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1 if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int32(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { times = uintptr(0) } @@ -136509,11 +136509,11 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r 2: int32(s1), 3: ns1, } - v2 = bp + 32 + v1 = bp + 32 } else { - v2 = uintptr(0) + v1 = uintptr(0) } - r = int32(X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v2), flags)) + r = int32(X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v1), flags)) if r != -int32(ENOSYS) || flags != 0 { return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -136536,7 +136536,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r goto _3 _3: ; - i++ + i = i + 1 } } r = int32(X__syscall3(tls, int32(SYS_futimesat), fd, int32(path), int32(tv))) @@ -136645,19 +136645,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -136702,7 +136702,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 20 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -136778,10 +136778,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var cnt Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec - _, _, _, _, _ = cnt, v1, v2, v3, v4 + _, _, _, _ = cnt, v1, v3, v4 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, @@ -136800,23 +136800,23 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { cnt = v1 if cnt <= 0 { if cnt != 0 { - v2 = int32(F_ERR) + v1 = int32(F_ERR) } else { - v2 = int32(F_EOF) + v1 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v1) return uint32(0) } if Uint32FromInt32(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint32FromInt32(cnt) } - cnt = Tssize_t(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint32(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -136838,12 +136838,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(16) defer tls.Free(16) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint32 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -136867,11 +136867,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint32(0) @@ -136880,11 +136880,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint32FromInt32(cnt) + rem = rem - Uint32FromInt32(cnt) if Uint32FromInt32(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 8 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint32FromInt32(cnt) @@ -136914,9 +136914,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) @@ -136930,9 +136930,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -136953,8 +136953,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -136965,9 +136965,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -137136,8 +137136,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -137146,9 +137146,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -137219,7 +137219,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -137332,16 +137332,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -137355,7 +137355,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137369,11 +137369,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+76) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) @@ -137394,9 +137394,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -137421,7 +137421,7 @@ func _locking_getc(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -137456,7 +137456,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -137479,9 +137479,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -137492,21 +137492,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v7) - int32(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -137543,12 +137543,12 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v2, v4, v5 int32 + var __need_unlock, c, v1, v2 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v3 uint32 var v8 int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v6, v7, v8 p = s if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -137567,16 +137567,16 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*int8)(unsafe.Pointer(s)) = 0 return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) if z != 0 { - v2 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) + v1 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) } else { - v2 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + v1 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) } - k = Uint32FromInt32(v2) + k = Uint32FromInt32(v1) if k < Uint32FromInt32(n) { v3 = k } else { @@ -137585,8 +137585,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - p += uintptr(k) - n = int32(uint32(n) - k) + p = p + uintptr(k) + n = Int32FromUint32(uint32(n) - k) if z != 0 || !(n != 0) { break } @@ -137594,24 +137594,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v2 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = int8(c) - v9 = p - p++ - *(*int8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v6)) = v8 if int32(v8) == int32('\n') { break } @@ -137658,7 +137658,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -137748,22 +137748,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+76) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -137781,7 +137781,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -137791,11 +137791,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -137909,7 +137909,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -138072,11 +138072,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = -int32(1) remain = len1 @@ -138090,8 +138090,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint32FromInt32(ret) - remain -= Uint32FromInt32(ret) + readlen = readlen + Uint32FromInt32(ret) + remain = remain - Uint32FromInt32(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint32(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -138103,10 +138103,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -138118,9 +138118,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -138248,10 +138248,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v6, v7 int32 + var v1, v6 int32 var v2 uint8 - var v3, v4, v5 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v3, v4 uintptr + _, _, _, _, _ = v1, v2, v3, v4, v6 if _a_cas(tls, f+76, 0, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0 { ___lockfile(tls, f) } @@ -138259,7 +138259,7 @@ func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -138267,16 +138267,16 @@ func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { } c = v1 if _a_swap(tls, f+76, 0)&int32(MAYBE_WAITERS) != 0 { - v5 = f + 76 + v3 = f + 76 + v1 = int32(1) v6 = int32(1) - v7 = int32(1) - if v7 != 0 { - v7 = int32(FUTEX_PRIVATE) + if v6 != 0 { + v6 = int32(FUTEX_PRIVATE) } - if v6 < Int32FromInt32(0) { - v6 = int32(INT_MAX) + if v1 < Int32FromInt32(0) { + v1 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)|v6), v1) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)), v1) != 0 } return c } @@ -138298,7 +138298,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -138356,7 +138356,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -138486,8 +138486,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint32 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint32 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -138511,8 +138511,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -138520,11 +138520,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint32(0) + v2 = uint32(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138534,8 +138534,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138579,7 +138579,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFL)), fl))) < 0 { goto fail } @@ -138646,8 +138646,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -138655,7 +138655,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + off = off - int64(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -138675,9 +138675,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138754,10 +138754,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos) - int32((*TFILE)(unsafe.Pointer(f)).Frend)) + pos = pos + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64(int32((*TFILE)(unsafe.Pointer(f)).Fwpos) - int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) + pos = pos + int64(int32((*TFILE)(unsafe.Pointer(f)).Fwpos)-int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -138870,7 +138870,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int32(0x7fffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -138894,7 +138894,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -138903,9 +138903,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138928,11 +138928,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138980,15 +138980,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -139067,7 +139067,7 @@ func _locking_getc1(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -139102,7 +139102,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139135,7 +139135,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -139169,7 +139169,7 @@ func _locking_getc2(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -139204,7 +139204,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139229,7 +139229,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139242,11 +139242,11 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v3, v4, v5 int32 + var __need_unlock, c, v1, v3 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v6, v7 i = uint32(0) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -139270,11 +139270,11 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, delim, Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) if z != 0 { - v3 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) + v1 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) } else { - v3 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + v1 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) } - k = Uint32FromInt32(v3) + k = Uint32FromInt32(v1) } else { z = uintptr(0) k = uint32(0) @@ -139282,7 +139282,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint32(2) if !(z != 0) && m < Uint32FromUint32(0xffffffff)/Uint32FromInt32(4) { - m += m / uint32(2) + m = m + m/uint32(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -139309,7 +139309,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -139317,14 +139317,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v3 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v3 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -139336,14 +139336,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint32(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 4 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 4 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break @@ -139395,7 +139395,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139406,7 +139406,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) } *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 @@ -139585,17 +139585,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint32(1184)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint32(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint32(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139611,9 +139611,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*int8)(unsafe.Pointer(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139729,17 +139729,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint32(172)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint32(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint32(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139755,9 +139755,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139848,10 +139848,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v6, v7 int32 + var v1, v6 int32 var v2 uint8 - var v3, v4, v5 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v3, v4 uintptr + _, _, _, _, _ = v1, v2, v3, v4, v6 if _a_cas(tls, f+76, 0, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0 { ___lockfile(tls, f) } @@ -139859,7 +139859,7 @@ func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139867,16 +139867,16 @@ func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { } c = v1 if _a_swap(tls, f+76, 0)&int32(MAYBE_WAITERS) != 0 { - v5 = f + 76 + v3 = f + 76 + v1 = int32(1) v6 = int32(1) - v7 = int32(1) - if v7 != 0 { - v7 = int32(FUTEX_PRIVATE) + if v6 != 0 { + v6 = int32(FUTEX_PRIVATE) } - if v6 < Int32FromInt32(0) { - v6 = int32(INT_MAX) + if v1 < Int32FromInt32(0) { + v1 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)|v6), v1) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)), v1) != 0 } return c } @@ -139898,7 +139898,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139934,7 +139934,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139960,10 +139960,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v6, v7 int32 + var v1, v6 int32 var v2 uint8 - var v3, v4, v5 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v3, v4 uintptr + _, _, _, _, _ = v1, v2, v3, v4, v6 if _a_cas(tls, f+76, 0, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0 { ___lockfile(tls, f) } @@ -139971,7 +139971,7 @@ func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139979,16 +139979,16 @@ func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { } c = v1 if _a_swap(tls, f+76, 0)&int32(MAYBE_WAITERS) != 0 { - v5 = f + 76 + v3 = f + 76 + v1 = int32(1) v6 = int32(1) - v7 = int32(1) - if v7 != 0 { - v7 = int32(FUTEX_PRIVATE) + if v6 != 0 { + v6 = int32(FUTEX_PRIVATE) } - if v6 < Int32FromInt32(0) { - v6 = int32(INT_MAX) + if v1 < Int32FromInt32(0) { + v1 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)|v7), v6) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v5), int32(Int32FromInt32(FUTEX_WAKE)), v6) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)|v6), v1) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v3), int32(Int32FromInt32(FUTEX_WAKE)), v1) != 0 } return c } @@ -140010,7 +140010,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -140038,7 +140038,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -140068,7 +140068,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -140404,7 +140404,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140439,7 +140439,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140475,7 +140475,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140509,7 +140509,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 4 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -140526,12 +140526,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 96 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { @@ -140548,10 +140548,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint32(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint32(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140560,13 +140560,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 4 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 4 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint32FromInt32(l)) + v4 = f + 4 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint32FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140842,7 +140842,7 @@ func _pad3(tls *TLS, f uintptr, c int8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint32(l) - Uint32FromInt64(256)) + l = Int32FromUint32(uint32(l) - Uint32FromInt64(256)) } _out(tls, f, bp, Uint32FromInt32(l)) } @@ -140856,13 +140856,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140874,45 +140874,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint32 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > uint64(Uint32FromUint32(2)*Uint32FromInt32(0x7fffffff)+Uint32FromInt32(1))) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = uint32(x) for { if !(y != 0) { break } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = Int8FromUint32(uint32('0') + y%uint32(10)) + s = s - 1 + v2 = s + *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + y%uint32(10)) goto _3 _3: ; - y /= uint32(10) + y = y / uint32(10) } return s } @@ -140927,12 +140927,12 @@ type Tcompiler_defines_long_double_incorrectly = [1]int8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v36, v37, v38, v39, v40, v41, v42, v45, v52, v57, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7, v8, v9 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 + var v1 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140941,7 +140941,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]int8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v5, v6, v7, v8, v9 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1419 ebuf = bp + 538 + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) @@ -140954,21 +140954,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*int8)(unsafe.Pointer(v10)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v11)) = int8(v12) - estr-- - v13 = estr - *(*int8)(unsafe.Pointer(v13)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*int8)(unsafe.Pointer(v14)) = int8(int32(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int32(s)-t__predefined_ptrdiff_t(bp+516) == int32(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*int8)(unsafe.Pointer(v15)) = int8('.') + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8('.') } } if p > Int32FromInt32(INT_MAX)-Int32FromInt32(2)-(int32(ebuf)-int32(estr))-pl { @@ -141080,46 +141080,46 @@ _4: _out(tls, f, estr, Uint32FromInt32(int32(ebuf)-int32(estr))) _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint32FromInt64(504)/Uint32FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint32FromInt64(504)/Uint32FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -141135,22 +141135,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -141169,21 +141169,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int32(z)-int32(b))/4 > need { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -141195,8 +141195,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -141206,10 +141206,10 @@ _4: if j < int32(9)*((int32(z)-int32(r))/4-int32(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -141217,15 +141217,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -141237,23 +141237,23 @@ _4: } } if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) @@ -141264,8 +141264,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -141284,14 +141284,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -141305,46 +141305,46 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) } if t|int32(32) == int32('f') { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))-j { - v37 = 0 + v8 = 0 } else { - v37 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j + v8 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j } - if p < v37 { - v36 = p + if p < v8 { + v7 = p } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))-j { - v38 = 0 + v9 = 0 } else { - v38 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j + v9 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j } - v36 = v38 + v7 = v9 } - p = v36 + p = v7 } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))+e-j { - v40 = 0 + v8 = 0 } else { - v40 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j + v8 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j } - if p < v40 { - v39 = p + if p < v8 { + v7 = p } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))+e-j { - v41 = 0 + v9 = 0 } else { - v41 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j + v9 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j } - v39 = v41 + v7 = v9 } - p = v39 + p = v7 } } } @@ -141357,35 +141357,35 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int32(ebuf)-int32(estr) < int32(2) { - estr-- - v43 = estr - *(*int8)(unsafe.Pointer(v43)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v44)) = int8(v45) - estr-- - v46 = estr - *(*int8)(unsafe.Pointer(v46)) = int8(t) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t) if int32(ebuf)-int32(estr) > int32(INT_MAX)-l { return -int32(1) } - l += int32(ebuf) - int32(estr) + l = l + (int32(ebuf) - int32(estr)) } if l > int32(INT_MAX)-pl { return -int32(1) @@ -141405,15 +141405,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*int8)(unsafe.Pointer(v48)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*int8)(unsafe.Pointer(v49)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } _out(tls, f, s2, Uint32FromInt32(int32(bp+516+uintptr(9))-int32(s2))) @@ -141431,21 +141431,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*int8)(unsafe.Pointer(v51)) = int8('0') + s3 = s3 - 1 + v5 = s3 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint32FromInt32(v52)) + _out(tls, f, s3, Uint32FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, int8('0'), p+int32(9), int32(9), 0) } else { @@ -141459,31 +141459,31 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*int8)(unsafe.Pointer(v54)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*int8)(unsafe.Pointer(v55)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint32(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint32(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+483, uint32(1)) } } if int32(bp+516+UintptrFromInt32(9))-int32(s4) < p { - v57 = int32(bp+516+UintptrFromInt32(9)) - int32(s4) + v7 = int32(bp+516+UintptrFromInt32(9)) - int32(s4) } else { - v57 = p + v7 = p } - _out(tls, f, s4, Uint32FromInt32(v57)) - p -= int32(bp+516+uintptr(9)) - int32(s4) + _out(tls, f, s4, Uint32FromInt32(v7)) + p = p - (int32(bp+516+uintptr(9)) - int32(s4)) goto _53 _53: ; @@ -141494,11 +141494,11 @@ _4: } _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -141517,7 +141517,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -141525,17 +141525,17 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v34, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st, v31 uint32 var i Tsize_t - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]int8 var _ /* mb at bp+48 */ [4]int8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -141548,7 +141548,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -141561,7 +141561,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -141571,8 +141571,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int32(z)-int32(a) > int32(INT_MAX)-cnt { goto overflow @@ -141587,10 +141587,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -141598,11 +141598,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -141614,7 +141614,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -141623,19 +141623,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -141648,16 +141648,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -141665,7 +141665,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141681,7 +141681,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -141720,11 +141720,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141800,14 +141800,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint32(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141833,10 +141833,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141851,30 +141851,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z goto _30 } if p > int32(z)-int32(a)+BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) { - v34 = p + v5 = p } else { - v34 = int32(z) - int32(a) + BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) + v5 = int32(z) - int32(a) + BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) } - p = v34 + p = v5 goto _30 goto narrow_c narrow_c: ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*int8)(unsafe.Pointer(v35)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141888,24 +141888,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + v8 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) } else { - v39 = __ccgo_ts + 1460 + v8 = __ccgo_ts + 1460 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v5))) if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(z) - int32(a) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141919,23 +141919,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) - v42 = Int32FromInt32(0) - l = v42 - i = Uint32FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint32FromInt32(v5) for { if v45 = i < Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) } if l < 0 { return -int32(1) @@ -141948,28 +141948,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) i = uint32(0) for { - if v49 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint32FromInt32(v47) <= Uint32FromInt32(p)) { + if !(v45 && i+Uint32FromInt32(v5) <= Uint32FromInt32(p)) { break } _out(tls, f, bp+48, Uint32FromInt32(l)) goto _46 _46: ; - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) } _pad3(tls, f, int8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -142034,7 +142034,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142043,7 +142043,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint32(NL_ARGMAX) { goto inval @@ -142069,12 +142069,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+124 */ [80]uint8 var _ /* nl_arg at bp+44 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -142113,11 +142113,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint32(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -142171,7 +142171,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142185,17 +142185,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -142218,99 +142218,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 4 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 4 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -142321,33 +142321,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -142401,14 +142401,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -142426,85 +142426,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 4 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 4 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint32(257)) @@ -142518,10 +142518,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -142529,11 +142529,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint32(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -142545,36 +142545,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint32(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = v63 + k = v59 if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint32(4)) @@ -142587,16 +142587,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 4 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -142607,12 +142607,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp = Xrealloc(tls, wcs, k*uint32(4)) if !(tmp != 0) { goto alloc_fail @@ -142631,23 +142631,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 4 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v73))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) if i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -142656,40 +142656,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 4 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 4 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v79))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 4 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142697,7 +142697,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142720,26 +142720,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142754,15 +142754,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -142771,6 +142763,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142786,20 +142786,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142811,7 +142811,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142820,7 +142820,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142992,7 +142992,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -143049,7 +143049,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -143057,7 +143057,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+16 */ [16]int8 var _ /* s at bp+4 */ uintptr var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 4)) = fmt l10n = uint32(0) cnt = 0 @@ -143070,7 +143070,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0) { break } @@ -143094,7 +143094,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 } if (int32(z)-int32(a))/4 > int32(INT_MAX)-cnt { goto overflow @@ -143109,7 +143109,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 @@ -143120,7 +143120,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-int32(' ')) goto _4 _4: ; @@ -143132,7 +143132,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -143147,13 +143147,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+4) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+4) + w = v5 + if v5 < 0 { goto overflow } } @@ -143162,16 +143162,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 } else { goto inval } @@ -143227,7 +143227,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -143269,11 +143269,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -143294,27 +143294,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = __ccgo_ts + 1460 } bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -143329,13 +143329,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+32, uint32(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -143387,7 +143387,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -143396,7 +143396,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -143488,7 +143488,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -143531,7 +143531,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -143552,14 +143552,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -143584,23 +143584,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 4 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143611,37 +143611,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 4 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 4 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143650,7 +143650,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -143660,7 +143660,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -143671,8 +143671,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -143685,9 +143685,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -143759,45 +143759,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 4 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 4 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 4 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143824,8 +143824,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143844,17 +143844,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143862,11 +143862,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint32(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = v35 + k = v4 if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint32(4)) if !(wcs != 0) { @@ -143881,27 +143881,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 4 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, wcs, k*uint32(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143911,17 +143911,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) if alloc != 0 && i > k-uint32(4) { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143930,16 +143930,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 4 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143997,23 +143997,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint32(22), __ccgo_ts+1503, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1521, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -144021,7 +144021,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -144033,7 +144033,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -144042,7 +144042,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -144123,8 +144123,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint32 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint32 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Fwpos)-int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144138,11 +144138,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -144263,11 +144263,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -144285,9 +144285,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint32FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint32FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -144301,9 +144301,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint32FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -144348,9 +144348,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint32(0) @@ -144368,10 +144368,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint32(0) } - v3 = f + 4 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 4 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint32(1) } @@ -144490,9 +144490,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144503,27 +144503,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int32) { @@ -144531,9 +144531,9 @@ func Xatol(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144544,27 +144544,27 @@ func Xatol(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - int32(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatoll(tls *TLS, s uintptr) (r int64) { @@ -144586,19 +144586,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144623,11 +144623,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint32(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint32(2) + nel = nel / uint32(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint32(2) + uint32(1) + nel = nel - (nel/uint32(2) + uint32(1)) } else { return try } @@ -144654,9 +144654,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]int8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -144673,9 +144673,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = 0 *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144860,9 +144860,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144871,7 +144871,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { - n = int32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) + n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint32(0) } @@ -144882,7 +144882,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { - n = int32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) + n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = uint32(0) } @@ -144894,10 +144894,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(240) defer tls.Free(240) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [57]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[57]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144908,16 +144908,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144948,12 +144948,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -145000,13 +145000,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0]&uint32(3) == uint32(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+192, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) @@ -145022,17 +145022,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[int32(1)] != uint32(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+192) _shr(tls, bp+192, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+192, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 192)) ^= uint32(7) _shr(tls, bp+192, int32(1)) _trinkle(tls, head-uintptr((*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) @@ -145040,7 +145040,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -145071,9 +145071,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(144) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -145083,11 +145083,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145260,7 +145260,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145268,7 +145268,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint32(1) } @@ -145279,11 +145279,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(208) defer tls.Free(208) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145304,11 +145304,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp+64)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145364,7 +145364,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145372,7 +145372,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint32(1) } @@ -145383,11 +145383,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(208) defer tls.Free(208) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145408,11 +145408,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp+64)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145522,9 +145522,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -145540,9 +145540,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 { goto tail @@ -145558,7 +145558,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -145566,19 +145566,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145617,8 +145617,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) @@ -145631,7 +145631,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 4 - n -= Uint32FromInt64(4) + n = n - Uint32FromInt64(4) } s = w } @@ -145642,8 +145642,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -145670,9 +145670,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -145690,9 +145690,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -145700,14 +145700,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint32(d)%uint32(4) == uint32(0) { for { @@ -145721,32 +145721,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint32(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint32(16) } if n&uint32(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint32(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint32(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint32(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145757,22 +145757,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint32(d) % Uint32FromInt32(4) { case uint32(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint32(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint32(3) for { if !(n >= uint32(17)) { break @@ -145788,23 +145788,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint32(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint32(16) } case uint32(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint32(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint32(2) for { if !(n >= uint32(18)) { break @@ -145820,18 +145820,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint32(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint32(16) } case uint32(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint32(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint32(1) for { if !(n >= uint32(19)) { break @@ -145847,170 +145847,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint32(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint32(16) } break } } if n&uint32(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint32(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint32(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint32(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint32(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -146020,27 +146020,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -146182,29 +146182,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -146239,22 +146239,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint32(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint32(0) goto _9 } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146262,10 +146262,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint32(0) goto _9 } @@ -146278,12 +146278,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -146313,7 +146313,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint32(1) { return h } - k -= Uint32FromInt32(int32(h) - int32(h0)) + k = k - Uint32FromInt32(int32(h)-int32(h0)) if k < l { return uintptr(0) } @@ -146338,9 +146338,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -146353,14 +146353,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for uint32(d)%Uint32FromInt64(4) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) } for { @@ -146371,42 +146371,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint32FromInt64(4) - d += uintptr(Uint32FromInt64(4)) - s += uintptr(Uint32FromInt64(4)) + n = n - Uint32FromInt64(4) + d = d + uintptr(Uint32FromInt64(4)) + s = s + uintptr(Uint32FromInt64(4)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = *(*int8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for uint32(d+uintptr(n))%Uint32FromInt64(4) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint32FromInt64(4) { - n -= Uint32FromInt64(4) + n = n - Uint32FromInt64(4) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } } @@ -146433,7 +146433,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -146491,9 +146491,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint32(s) & uint32(3) - s += uintptr(k) - n -= k - n &= Uint32FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint32FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -146524,8 +146524,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint32(24) + uint32(s)&uint32(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -146541,8 +146541,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint32(32) - s += uintptr(32) + n = n - uint32(32) + s = s + uintptr(32) } return dest } @@ -146572,8 +146572,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 int8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 int8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for { if !(uint32(s)%Uint32FromInt64(4) != 0) { @@ -146587,8 +146587,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -146609,16 +146609,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -146657,9 +146657,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 int8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 int8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { @@ -146672,9 +146672,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { goto tail @@ -146689,7 +146689,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -146697,19 +146697,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -146751,8 +146751,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146791,7 +146791,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146854,7 +146854,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s @@ -146875,7 +146875,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146909,8 +146909,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146931,10 +146931,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [8]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { return Uint32FromInt32(int32(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int32(a)) @@ -146942,16 +146942,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint32(32)) for { if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + v2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { @@ -146960,7 +146960,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } @@ -147042,12 +147042,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 int8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 int8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -147063,9 +147063,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { wd = d @@ -147078,7 +147078,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -147087,19 +147087,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*int8)(unsafe.Pointer(d)) = 0 goto finish @@ -147138,7 +147138,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -147158,7 +147158,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } @@ -147174,7 +147174,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147185,9 +147185,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -147213,21 +147213,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*int8)(unsafe.Pointer(v3)) = 0 + v1 = d + d = d + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 return a } @@ -147242,7 +147242,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147253,9 +147253,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -147311,7 +147311,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*int8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147342,7 +147342,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { end = uintptr(0) @@ -147368,7 +147368,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -147379,12 +147379,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -147396,10 +147396,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [8]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[8]Tsize_t)(unsafe.Pointer(bp)) = [8]Tsize_t{} if !(*(*int8)(unsafe.Pointer(c)) != 0) { @@ -147413,22 +147413,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } for { if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + v3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { @@ -147437,18 +147437,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147580,29 +147580,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147639,7 +147639,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -147649,22 +147649,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint32(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint32(0) goto _9 } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -147672,10 +147672,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint32(0) goto _9 } @@ -147688,12 +147688,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -147741,9 +147741,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -147751,17 +147751,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v1 = _p2 + _p2 = _p2 + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { _p2 = uintptr(0) } @@ -147775,9 +147775,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147785,18 +147785,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147839,7 +147839,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147855,7 +147855,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147884,12 +147884,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int32(2) + n = n - int32(2) } } @@ -148089,7 +148089,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -148102,7 +148102,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -148120,21 +148120,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -148152,7 +148152,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148178,7 +148178,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -148210,7 +148210,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -148265,10 +148265,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint32 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint32(0) for { @@ -148278,7 +148278,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -148292,23 +148292,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -148317,29 +148317,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -148376,16 +148376,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -148393,10 +148393,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint32(0) goto _9 } @@ -148409,12 +148409,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -148450,9 +148450,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -148460,18 +148460,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -148500,7 +148500,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -148525,7 +148525,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148553,7 +148553,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148572,8 +148572,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -148581,7 +148581,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint32(d)-uint32(s) < n*uint32(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148589,9 +148589,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -148615,7 +148615,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148648,7 +148648,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148673,27 +148673,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint32(6) || Uint32FromInt32(len1) > l-uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148756,7 +148756,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148967,7 +148967,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -149018,38 +149018,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -149057,15 +149057,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(int32(_days_in_month[months]) <= remdays) { break } - remdays -= int32(_days_in_month[months]) + remdays = remdays - int32(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -149111,19 +149111,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -149160,7 +149160,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -149170,20 +149170,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -149202,21 +149202,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -149227,7 +149227,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -149239,10 +149239,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -149256,7 +149256,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -149282,13 +149282,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += x * uint32(*(*uint8)(unsafe.Pointer(v))) + y = y + x*uint32(*(*uint8)(unsafe.Pointer(v))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -149298,12 +149298,12 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v6, v7 int32 + var posix_form, scale, v2, v6 int32 var _ /* buf at bp+6 */ [280]int8 var _ /* dummy_name at bp+301 */ [7]int8 var _ /* p at bp+292 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1570) @@ -149327,7 +149327,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -149341,7 +149341,7 @@ func _do_tzset(tls *TLS) { i = Uint32FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint32(2) + _old_tz_size = _old_tz_size * uint32(2) if i >= _old_tz_size { _old_tz_size = i + uint32(1) } @@ -149366,7 +149366,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1573) != 0) { @@ -149388,7 +149388,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint32(1)) + try = try + uintptr(l+uint32(1)) } } } @@ -149415,7 +149415,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint32(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -149432,18 +149432,18 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = v7 - Xtimezone = v6 - Xdaylight = v6 + v6 = Int32FromInt32(0) + _dst_off = v6 + v2 = v6 + Xtimezone = v2 + Xdaylight = v2 p1 = _types for { if !(p1 < _abbrevs) { @@ -149461,7 +149461,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -149496,11 +149496,11 @@ func _do_tzset(tls *TLS) { _dst_off = Xtimezone } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149538,10 +149538,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint32(1)))))))) } if t-int64(off) < Int64FromUint64(x) { - n /= uint32(2) + n = n / uint32(2) } else { a = m - n -= n / uint32(2) + n = n - n/uint32(2) } } /* First and last entry are special. First means to use lowest-index @@ -149570,7 +149570,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint32(6) + i = i - uint32(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -149621,25 +149621,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -149682,16 +149682,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += int64(Xtimezone) - t1 += int64(_dst_off) + t0 = t0 + int64(Xtimezone) + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -149764,7 +149764,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -149781,8 +149781,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149792,15 +149792,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149810,11 +149810,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -150302,9 +150302,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+36, bp+44, bp+40) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= int64(*(*int32)(unsafe.Pointer(bp + 44)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64(*(*int32)(unsafe.Pointer(bp + 44))-(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) if t != t { goto error } @@ -150332,9 +150332,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -150345,7 +150345,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -150354,7 +150354,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -150378,10 +150378,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1495 width = int32(2) def_pad = int32('0') @@ -150435,14 +150435,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -150459,7 +150459,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -150490,11 +150490,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) @@ -150503,14 +150503,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -150534,11 +150534,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -150598,11 +150598,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) case int32('_'): @@ -150644,15 +150644,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(112) defer tls.Free(112) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint32 var v9 bool var _ /* buf at bp+4 */ [100]int8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+104 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint32(0) for { if !(l < n) { @@ -150664,21 +150664,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = int32(*(*int8)(unsafe.Pointer(v3))) } v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+104, int32(10)) @@ -150695,7 +150695,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 104)) if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+4, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -150706,8 +150706,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -150716,8 +150716,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -150730,50 +150730,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v7))) = int8('-') - width-- + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v8) { - v10 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v10))) = int8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v4) { + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v12))) = int8('0') + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -150807,15 +150807,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+12 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -150839,21 +150839,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint32(Xstrtoul(tls, f, bp+12, int32(10))) @@ -150863,7 +150863,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch int32(*(*int8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150960,7 +150960,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -151015,19 +151015,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*int8)(unsafe.Pointer(s)) != 0; v48 { - v45 = int32(*(*int8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { + v1 = int32(*(*int8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -151039,7 +151039,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -151047,7 +151047,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -151111,7 +151111,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -151124,9 +151124,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if int32(*(*int8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -151145,13 +151145,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -151166,30 +151166,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -151209,13 +151209,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -151468,7 +151468,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(512) defer tls.Free(512) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint32 @@ -151476,7 +151476,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+504 */ uintptr var _ /* wbuf at bp+104 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint32(0) for { if !(l < n) { @@ -151488,7 +151488,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -151534,40 +151534,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151720,8 +151720,8 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { trc("tls=%v old=%v new1=%v flags=%v, (%v:)", tls, old, new1, flags, origin(2)) defer func() { trc("-> %v", r1) }() } - var r, v1, v2 int32 - _, _, _ = r, v1, v2 + var r, v1 int32 + _, _ = r, v1 if old == new1 { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } @@ -151741,9 +151741,9 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) - r = v2 - if !(v2 == -int32(EBUSY)) { + v1 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) + r = v1 + if !(v1 == -int32(EBUSY)) { break } } @@ -151974,7 +151974,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*int8)(unsafe.Pointer(name + uintptr(i-uint32(1)))) = 0 @@ -152137,7 +152137,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_amd64.go b/vendor/modernc.org/libc/ccgo_linux_amd64.go index a93029e..c644139 100644 --- a/vendor/modernc.org/libc/ccgo_linux_amd64.go +++ b/vendor/modernc.org/libc/ccgo_linux_amd64.go @@ -600,14 +600,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -616,8 +616,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -948,18 +948,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -991,9 +991,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -1043,9 +1043,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1089,18 +1089,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1108,18 +1108,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1178,8 +1178,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1200,42 +1200,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1249,11 +1249,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1263,17 +1263,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1284,11 +1284,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1301,17 +1301,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1324,11 +1324,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1340,8 +1340,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1357,92 +1357,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1475,14 +1475,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1496,32 +1496,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1540,11 +1540,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1559,12 +1559,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1576,32 +1576,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1620,11 +1620,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1891,18 +1891,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1910,18 +1910,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1934,8 +1934,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1956,42 +1956,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -2005,11 +2005,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2018,17 +2018,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2039,11 +2039,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2058,17 +2058,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2081,11 +2081,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2097,8 +2097,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2114,92 +2114,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2243,13 +2243,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2264,29 +2264,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2317,8 +2317,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2326,22 +2326,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2363,13 +2363,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2384,29 +2384,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2414,21 +2414,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2442,18 +2442,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2476,18 +2476,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2495,18 +2495,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2517,15 +2517,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2568,15 +2568,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2619,11 +2619,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2633,15 +2633,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2666,50 +2666,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7448,13 +7448,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7510,14 +7510,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7532,14 +7532,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= uint64(PAGESIZE) + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7548,7 +7548,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -8924,16 +8924,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8942,10 +8942,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8954,16 +8954,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8972,16 +8972,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8990,58 +8990,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9061,7 +9061,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9072,12 +9072,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9085,36 +9085,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9122,9 +9122,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9133,10 +9133,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9183,9 +9183,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9202,25 +9202,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9231,11 +9231,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9260,7 +9260,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9273,7 +9273,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9290,13 +9290,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9309,7 +9309,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9334,7 +9334,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9342,7 +9342,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9361,9 +9361,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9372,7 +9372,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) @@ -11255,7 +11255,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11282,14 +11282,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11299,8 +11299,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11335,35 +11335,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11376,10 +11376,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11393,19 +11393,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11416,7 +11416,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11432,10 +11432,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11444,7 +11444,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11454,23 +11454,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11501,12 +11501,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11516,10 +11516,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11539,11 +11539,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11558,11 +11558,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11574,12 +11574,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11788,7 +11788,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11796,60 +11796,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11862,7 +11862,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -11906,7 +11906,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -11923,8 +11923,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -11935,8 +11935,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -11976,15 +11976,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12015,7 +12015,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12054,7 +12054,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12084,13 +12084,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v5)) = int8('$') i = uint32(0) for { @@ -12101,7 +12101,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -12301,7 +12301,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12311,7 +12311,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12339,7 +12339,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12356,7 +12356,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12404,7 +12404,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12421,8 +12421,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12433,8 +12433,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12446,15 +12446,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12478,7 +12478,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12521,7 +12521,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12554,7 +12554,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12581,7 +12581,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12595,7 +12595,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12609,7 +12609,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12639,11 +12639,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12653,7 +12653,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -12963,7 +12963,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12980,8 +12980,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -12992,8 +12992,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -13005,15 +13005,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13037,7 +13037,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -13065,7 +13065,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13090,7 +13090,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13123,7 +13123,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13150,7 +13150,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13164,7 +13164,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13178,7 +13178,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13208,11 +13208,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13222,7 +13222,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -13370,9 +13370,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13384,18 +13384,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17513,8 +17513,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22231,7 +22231,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22270,10 +22270,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22339,15 +22339,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22358,15 +22358,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -24922,10 +24922,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -24960,16 +24960,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -25039,7 +25039,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25159,7 +25159,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25261,7 +25261,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25273,7 +25273,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25718,7 +25718,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25742,7 +25742,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25786,7 +25786,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -26054,15 +26054,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26071,23 +26071,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26097,18 +26097,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26116,58 +26116,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26192,7 +26192,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26202,32 +26202,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26243,7 +26243,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26252,15 +26252,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26271,14 +26271,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26288,7 +26288,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26296,11 +26296,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26332,12 +26332,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26362,19 +26362,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26387,24 +26387,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26465,7 +26465,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26476,11 +26476,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26492,29 +26492,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26527,40 +26527,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26587,11 +26587,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26605,7 +26605,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26621,26 +26621,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26652,15 +26652,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26684,41 +26684,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26730,15 +26730,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26748,10 +26748,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26765,13 +26765,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26783,11 +26783,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26799,10 +26799,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26821,7 +26821,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26837,16 +26837,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -26855,24 +26855,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -26880,12 +26880,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -26899,55 +26899,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -26955,26 +26955,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26982,19 +26982,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27268,11 +27268,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27283,7 +27283,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27301,42 +27301,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27355,7 +27355,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27369,18 +27369,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27388,18 +27388,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27413,18 +27413,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27547,7 +27547,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') @@ -27562,21 +27562,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27619,7 +27619,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28348,7 +28348,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28555,7 +28555,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && int32(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = 0 } @@ -29048,7 +29048,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30249,7 +30249,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31256,8 +31256,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31277,10 +31277,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31369,10 +31369,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98242,7 +98242,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98250,8 +98250,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98275,16 +98275,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98351,23 +98351,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98408,10 +98408,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98429,10 +98429,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98442,7 +98442,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]int8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98630,11 +98630,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98647,7 +98647,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98656,27 +98656,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98702,11 +98702,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98765,8 +98765,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98779,7 +98779,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -98803,7 +98803,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -98828,13 +98828,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -98852,17 +98852,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98871,9 +98871,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -98890,18 +98890,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -98973,7 +98973,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -98991,17 +98991,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -99092,7 +99092,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -99112,7 +99112,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -99130,7 +99130,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99139,17 +99139,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99161,24 +99161,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*int8)(unsafe.Pointer(v57)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v60)) = Int8FromUint32(v62) + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99187,7 +99187,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99197,14 +99197,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*int8)(unsafe.Pointer(v63)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*int8)(unsafe.Pointer(v65)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99216,56 +99216,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*int8)(unsafe.Pointer(v67)) = int8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*int8)(unsafe.Pointer(v69)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*int8)(unsafe.Pointer(v71)) = int8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*int8)(unsafe.Pointer(v73)) = int8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*int8)(unsafe.Pointer(v75)) = int8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*int8)(unsafe.Pointer(v77)) = int8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*int8)(unsafe.Pointer(v79)) = int8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*int8)(unsafe.Pointer(v81)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*int8)(unsafe.Pointer(v83)) = int8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*int8)(unsafe.Pointer(v85)) = int8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*int8)(unsafe.Pointer(v87)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99276,38 +99276,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*int8)(unsafe.Pointer(v89)) = int8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*int8)(unsafe.Pointer(v91)) = int8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*int8)(unsafe.Pointer(v93)) = int8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*int8)(unsafe.Pointer(v95)) = Int8FromUint32(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*int8)(unsafe.Pointer(v97)) = Int8FromUint32(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*int8)(unsafe.Pointer(v99)) = int8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*int8)(unsafe.Pointer(v101)) = int8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*int8)(unsafe.Pointer(v103)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99338,7 +99338,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99415,8 +99415,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99430,11 +99430,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 539 + v1 = __ccgo_ts + 539 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99471,13 +99471,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99546,11 +99546,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]int8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*int8)(unsafe.Pointer(val)) != 0) { @@ -99579,7 +99579,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 548 @@ -99647,11 +99647,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99755,7 +99755,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99783,7 +99783,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -99860,7 +99860,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -99871,7 +99871,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99981,7 +99981,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -99995,7 +99995,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -100039,7 +100039,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100095,10 +100095,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]int8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100134,7 +100134,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100147,7 +100147,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -100158,22 +100158,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = 0 + s = s - 1 + v3 = s + *(*int8)(unsafe.Pointer(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100186,11 +100186,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 539 + v3 = __ccgo_ts + 539 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100224,9 +100224,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100240,15 +100240,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100260,9 +100260,9 @@ _4: for { switch int32(*(*int8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = int32(*(*int8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100283,7 +100283,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100294,13 +100294,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100309,12 +100309,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100323,12 +100323,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100339,8 +100339,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100535,9 +100535,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100550,11 +100550,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100754,12 +100754,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100779,11 +100779,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101164,12 +101164,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101294,10 +101294,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101325,8 +101325,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101340,17 +101340,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101370,18 +101370,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101394,7 +101394,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101413,7 +101413,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101427,7 +101427,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101439,11 +101439,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101454,7 +101454,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101468,37 +101468,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101512,11 +101512,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101530,17 +101530,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101562,18 +101562,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101585,38 +101585,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101632,7 +101632,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101648,7 +101648,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101656,11 +101656,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101726,13 +101726,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -101889,12 +101889,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -101936,11 +101936,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102592,11 +102592,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102611,14 +102611,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102696,11 +102696,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -102813,11 +102813,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -102953,11 +102953,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -103121,12 +103121,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103164,8 +103164,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103416,7 +103416,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103425,7 +103425,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103442,10 +103442,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103565,12 +103565,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103606,11 +103606,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -103884,7 +103884,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -103919,12 +103919,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -103951,11 +103951,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -104069,7 +104069,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -104104,12 +104104,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104136,11 +104136,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104176,11 +104176,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104267,13 +104267,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104466,11 +104466,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104546,14 +104546,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104561,13 +104561,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104621,9 +104621,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104648,13 +104648,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104753,13 +104753,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -104894,7 +104894,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -104972,7 +104972,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -105029,7 +105029,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -105075,12 +105075,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105089,8 +105089,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105132,13 +105132,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105147,10 +105147,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105168,13 +105168,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105183,10 +105183,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105402,7 +105402,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105414,10 +105414,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105529,7 +105529,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) // __asm__( "bsr %1,%0 ; xor $63,%0" : "=r"(x) : "r"(x) ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 121, __ccgo_ts+583) @@ -105541,13 +105541,13 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105558,7 +105558,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { return float64(x1*y) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105591,7 +105591,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) - r += float64(Tdouble_t(tiny*tiny) * (r - r)) + r = r + float64(Tdouble_t(tiny*tiny)*(r-r)) } } else { /* only round once when scaled */ @@ -105624,13 +105624,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105639,27 +105639,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105667,11 +105667,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105681,13 +105681,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105696,27 +105696,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105724,11 +105724,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105746,13 +105746,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105761,27 +105761,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105789,11 +105789,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -105803,13 +105803,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105818,27 +105818,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -105846,11 +105846,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -105872,7 +105872,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -105885,7 +105885,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105933,13 +105933,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -105992,17 +105992,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106133,17 +106133,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106164,12 +106164,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106193,10 +106193,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106208,12 +106208,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106237,10 +106237,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106277,7 +106277,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106290,7 +106290,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106308,10 +106308,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106351,13 +106351,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106432,13 +106432,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106501,8 +106501,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106553,7 +106553,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106575,8 +106575,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106672,7 +106672,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -106828,7 +106828,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -106936,7 +106936,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -107016,7 +107016,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107161,7 +107161,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107269,7 +107269,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107360,7 +107360,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107507,7 +107507,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107614,7 +107614,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107696,7 +107696,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107838,7 +107838,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -107945,7 +107945,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -107985,7 +107985,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -107999,14 +107999,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -108049,7 +108049,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -108073,12 +108073,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -108091,8 +108091,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108107,7 +108107,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108132,7 +108132,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108145,14 +108145,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108179,15 +108179,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108253,7 +108253,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108263,11 +108263,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108281,7 +108281,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108292,14 +108292,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108313,7 +108313,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108336,12 +108336,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108353,8 +108353,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108369,7 +108369,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108394,7 +108394,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108407,14 +108407,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108440,13 +108440,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108483,7 +108483,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108492,11 +108492,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108605,8 +108605,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108712,7 +108712,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108720,11 +108720,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108736,20 +108736,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -108863,7 +108863,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -108969,7 +108969,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -108977,11 +108977,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -108993,20 +108993,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109134,9 +109134,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109162,31 +109162,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109292,8 +109292,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109488,7 +109488,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109498,7 +109498,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109588,7 +109588,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109598,7 +109598,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -109645,11 +109645,11 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { } var hi, invc, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, y1, z Tdouble_t var i, k int32 - var ix, iz, tmp, v12, v6 Tuint64_t + var ix, iz, tmp, v6 Tuint64_t var top Tuint32_t - var y, v1, v10, v11, v13, v14, v2, v3, v4, v7, v8 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5, v6 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109665,8 +109665,8 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - v7 = r - v6 = uint64(*(*Tuint64_t)(unsafe.Pointer(&v7)) & (-Uint64FromUint64(1) << Int32FromInt32(32))) + v1 = r + v6 = uint64(*(*Tuint64_t)(unsafe.Pointer(&v1)) & (-Uint64FromUint64(1) << Int32FromInt32(32))) rhi = *(*float64)(unsafe.Pointer(&v6)) rlo = r - rhi hi = Tdouble_t(rhi * X__log2_data.Finvln2hi) @@ -109676,31 +109676,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v10 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v11 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v11)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110335,9 +110335,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110435,9 +110435,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110494,8 +110494,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110509,7 +110509,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110538,32 +110538,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110701,12 +110701,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110793,16 +110793,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -110872,11 +110872,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, lhi, llo, x2, yhi, ylo Tdouble_t var ix, iy, v16, v17 Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v18, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v16, v17, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -110895,19 +110895,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -110921,14 +110921,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -110940,51 +110940,51 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111415,8 +111415,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111424,10 +111424,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111435,10 +111435,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111522,13 +111522,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111586,8 +111586,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111595,10 +111595,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111606,10 +111606,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111884,13 +111884,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -111906,10 +111906,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -111935,13 +111935,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -111957,10 +111957,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -112032,11 +112032,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -112045,11 +112045,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -112076,22 +112076,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112137,12 +112137,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112157,18 +112157,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112200,14 +112200,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112223,18 +112223,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112247,9 +112247,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112295,13 +112295,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112317,18 +112317,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112359,11 +112359,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112379,24 +112379,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112457,13 +112457,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112477,18 +112477,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112519,11 +112519,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112693,9 +112693,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112714,7 +112714,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112723,7 +112723,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112751,9 +112751,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -112863,7 +112863,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -112898,9 +112898,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -112910,13 +112910,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -112942,11 +112942,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -112961,18 +112961,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -113008,13 +113008,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -113028,18 +113028,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113056,28 +113056,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113275,8 +113275,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113376,7 +113376,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113389,7 +113389,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113459,7 +113459,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113472,10 +113472,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113486,7 +113486,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113633,12 +113633,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*int8)(unsafe.Pointer(p)) = 0 return uintptr(unsafe.Pointer(&_s)) @@ -113689,7 +113689,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113698,7 +113698,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113732,7 +113732,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113744,7 +113744,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113756,7 +113756,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*int8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = 0 return s @@ -113847,7 +113847,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -113862,11 +113862,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -113959,17 +113959,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114248,11 +114248,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114304,7 +114304,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114333,7 +114333,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114350,7 +114350,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114358,9 +114358,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114375,11 +114375,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114390,11 +114390,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114411,22 +114411,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114452,7 +114452,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+737, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114468,13 +114468,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 806 + v5 = __ccgo_ts + 806 } else { - v6 = __ccgo_ts + 713 + v5 = __ccgo_ts + 713 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114535,9 +114535,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint64 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall4(tls, int64(SYS_prlimit64), int64(Int32FromInt32(0)), int64(resource), int64(Int32FromInt32(0)), int64(rlim))))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114560,11 +114560,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114616,7 +114616,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114641,7 +114641,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -114929,15 +114929,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -114947,12 +114947,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -115000,7 +115000,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -115143,28 +115143,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*int8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*int8)(unsafe.Pointer(v3)) = *(*int8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115174,29 +115174,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*int8)(unsafe.Pointer(v7)) = Int8FromUint8(cval) + v1 = dest + dest = dest + 1 + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*int8)(unsafe.Pointer(v8)) = *(*int8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } } *(*int8)(unsafe.Pointer(dest)) = 0 @@ -115245,7 +115245,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+842, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115303,15 +115303,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(192) defer tls.Free(192) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+176 */ TFTW var _ /* new at bp+144 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115363,11 +115363,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel if h != 0 { @@ -115381,7 +115381,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115390,7 +115390,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) } @@ -115405,10 +115405,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115446,9 +115446,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115460,11 +115460,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115637,7 +115637,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115650,12 +115650,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]int8 var _ /* stack at bp+0 */ [4097]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115690,27 +115690,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') - p++ + p = p + 1 /* Initial // is special. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v5] = int8('/') + v4 = q + q = q + 1 + (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115720,17 +115720,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v7] = int8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 - p += l + p = p + l up = 0 if l0 == uint64(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115739,8 +115739,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115769,23 +115769,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115793,10 +115793,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115804,7 +115804,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115818,26 +115818,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]int8)(unsafe.Pointer(bp)))[v11] = int8('/') + v4 = l + l = l + 1 + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116361,19 +116361,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]int8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116391,12 +116391,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if int32((*(*[1024]int8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v2] = int8('\n') + v1 = l + l = l + 1 + (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v1] = int8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+666, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116649,7 +116649,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -116894,11 +116894,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -116937,9 +116937,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -116948,10 +116948,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -117113,12 +117113,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + wn = wn - 1 goto _4 _4: } @@ -117133,44 +117133,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117190,76 +117190,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117408,31 +117408,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*int8)(unsafe.Pointer(v7)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(4) } @@ -117478,16 +117478,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117503,9 +117503,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]int8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117519,9 +117519,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117541,13 +117541,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117566,13 +117566,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118687,9 +118687,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118700,8 +118700,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118713,20 +118713,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -118739,34 +118739,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -118780,17 +118780,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -118841,22 +118841,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -118878,9 +118878,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -118916,26 +118916,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*int8)(unsafe.Pointer(v3)) = int8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) } } else { *(*int8)(unsafe.Pointer(dest)) = 0 @@ -118948,7 +118948,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -118983,7 +118983,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119093,9 +119093,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119107,31 +119107,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -119139,7 +119139,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119481,7 +119481,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119493,7 +119493,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if int32(*(*int8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119533,11 +119533,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 993 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119580,9 +119580,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119591,15 +119591,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119616,7 +119616,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -119628,16 +119628,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -119740,7 +119740,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -119810,13 +119810,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -119947,7 +119947,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120012,15 +120012,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -120070,7 +120070,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120129,41 +120129,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120425,7 +120425,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120606,17 +120606,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120629,29 +120629,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8('.') - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+1024) } @@ -120661,15 +120661,15 @@ var _xdigits = [17]int8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', ' func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1033, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120684,7 +120684,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -120702,14 +120702,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120722,35 +120722,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*int8)(unsafe.Pointer(p)) != 0; v13 { - v10 = int32(*(*int8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*int8)(unsafe.Pointer(z)) != 0; v18 { - v15 = int32(*(*int8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if int64(z)-int64(p) < int64(256) { @@ -120764,7 +120764,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -120772,7 +120772,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]int8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1057, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -120782,7 +120782,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -120800,14 +120800,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -120907,7 +120907,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = int8('%') Xstrcat(tls, bp+78, p) @@ -121012,7 +121012,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121091,12 +121091,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(32) defer tls.Free(32) - var r, v17, v26, v8 int64 - var r1, v1, v10, v19 int32 + var r, v8 int64 + var r1, v1 int32 var tv uintptr - var v11, v12, v13, v14, v15, v16, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7 Tsyscall_arg_t + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t var _ /* tv32 at bp+8 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) v2 = int64(fd) @@ -121140,27 +121140,27 @@ _9: *(*[1]Tsocklen_t)(unsafe.Pointer(bp)) = [1]Tsocklen_t{ 0: uint32(16), } - v10 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v11 = int64(fd) - v12 = int64(level) - v13 = int64(optname) - v14 = int64(bp + 8) - v15 = int64(bp) - v16 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp + 8) + v6 = int64(bp) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v17 = r + v8 = r goto _18 } - v17 = r + v8 = r goto _18 _18: - r1 = int32(v17) + r1 = int32(v8) if r1 < 0 { break } @@ -121180,27 +121180,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v19 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v20 = int64(fd) - v21 = int64(level) - v22 = int64(optname) - v23 = int64(optval) - v24 = int64(optlen) - v25 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = int64(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v26 = r + v8 = r goto _27 } - v26 = r + v8 = r goto _27 _27: - r1 = int32(v26) + r1 = int32(v8) break } } @@ -121250,7 +121250,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -121262,16 +121262,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121442,7 +121442,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121488,14 +121488,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = 0 goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121517,9 +121517,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121529,11 +121529,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121581,7 +121581,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121611,7 +121611,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -121638,12 +121638,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Int8FromUint8(':') @@ -121770,7 +121770,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -121784,11 +121784,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -121809,7 +121809,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -121821,11 +121821,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -121835,7 +121835,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { @@ -121846,9 +121846,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*int8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*int8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -121856,22 +121856,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -121888,15 +121888,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -121909,7 +121909,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -121917,16 +121917,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -122005,7 +122005,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -122055,14 +122055,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122070,23 +122070,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122095,9 +122095,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122115,14 +122115,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122145,15 +122145,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122172,7 +122172,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122180,26 +122180,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*int8)(unsafe.Pointer(p)) != 0; v17 { - v14 = int32(*(*int8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*int8)(unsafe.Pointer(v18)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122211,35 +122211,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*int8)(unsafe.Pointer(p)) != 0; v23 { - v20 = int32(*(*int8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*int8)(unsafe.Pointer(z)) != 0; v28 { - v25 = int32(*(*int8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if _is_valid_hostname(tls, p) != 0 { @@ -122249,11 +122249,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122300,7 +122300,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122345,14 +122345,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122374,7 +122374,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122389,7 +122389,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122414,13 +122414,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]int8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122434,19 +122434,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*int8)(unsafe.Pointer(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122477,23 +122477,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v9 = int32(*(*int8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122579,7 +122579,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -122615,7 +122615,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -122635,7 +122635,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -122645,7 +122645,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*int8)(unsafe.Pointer(canon)) = 0 if name != 0 { @@ -122663,7 +122663,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -122697,7 +122697,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -122706,18 +122706,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -122735,7 +122735,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -122754,7 +122754,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -122808,31 +122808,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122979,19 +122979,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*int8)(unsafe.Pointer(p)) != 0; v19 { - v16 = int32(*(*int8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -123003,9 +123003,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1076, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -123013,18 +123013,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123187,34 +123187,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123229,21 +123229,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123256,14 +123256,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123290,7 +123290,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123301,18 +123301,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123329,8 +123329,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123365,22 +123365,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123391,7 +123391,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123514,7 +123514,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -123611,7 +123611,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -123623,11 +123623,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -123679,11 +123679,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -123692,14 +123692,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 40 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 40 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -123717,10 +123717,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v9 int64 var r1 Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4, v5, v6, v7, v8 Tsyscall_arg_t var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v3, v4, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -123730,7 +123730,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 msg = bp } - v2 = int32(SYS_recvmsg) + v1 = int32(SYS_recvmsg) _ = int32(__SC_recvmsg) v3 = int64(fd) v4 = int64(msg) @@ -123739,9 +123739,9 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v7 = int64(Int32FromInt32(0)) v8 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = ___syscall_cp(tls, int64(v1), v3, v4, v5, v6, v7, v8) } else { - r = X__syscall6(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = X__syscall6(tls, int64(v1), v3, v4, v5, v6, v7, v8) } if r != int64(-Int32FromInt32(ENOSYS)) { v9 = r @@ -123782,7 +123782,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -123810,7 +123810,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -123953,7 +123953,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -124021,9 +124021,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -124043,7 +124043,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -124064,7 +124064,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124134,7 +124134,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124148,7 +124148,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -124182,7 +124182,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124209,7 +124209,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124237,7 +124237,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124259,13 +124259,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124304,7 +124304,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124318,7 +124318,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124335,10 +124335,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124356,7 +124356,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124415,7 +124415,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124467,7 +124467,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124490,7 +124490,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124520,9 +124520,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124537,11 +124537,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -124571,16 +124571,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]int8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -124617,7 +124617,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1191) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -124630,103 +124630,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1198) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1208) if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1217, uint64(10)) != 0); v11 { - v8 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1217, uint64(10)) != 0); v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = int32(*(*int8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1228, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1235, uint64(6)) != 0; !v24 { - v21 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1228, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1235, uint64(6)) != 0; !v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = int32(*(*int8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -124786,7 +124786,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -124807,13 +124807,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1120) defer tls.Free(1120) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v12 int64 - var v1, v5 int32 + var v1 int32 var v10, v11, v6, v7, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+56 */ [66]Tcmsghdr var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -124842,15 +124842,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) + v1 = int32(SYS_sendmsg) _ = int32(__SC_sendmsg) v6 = int64(fd) v7 = int64(msg) @@ -124859,9 +124859,9 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v10 = int64(Int32FromInt32(0)) v11 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = ___syscall_cp(tls, int64(v1), v6, v7, v8, v9, v10, v11) } else { - r = X__syscall6(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = X__syscall6(tls, int64(v1), v6, v7, v8, v9, v10, v11) } if r != int64(-Int32FromInt32(ENOSYS)) { v12 = r @@ -124932,14 +124932,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, v18, v27, v8 int64 - var r1, v1, v11, v20 int32 + var r, v8 int64 + var r1, v1 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v10 uint64 - var v12, v13, v14, v15, v16, v17, v2, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8 + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) v2 = int64(fd) @@ -124995,27 +124995,27 @@ _9: 0: s, 1: int64(Int32FromUint64(v10)), } - v11 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v12 = int64(fd) - v13 = int64(level) - v14 = int64(optname) - v15 = int64(bp) - v16 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v17 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp) + v6 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v18 = r + v8 = r goto _19 } - v18 = r + v8 = r goto _19 _19: - r1 = int32(v18) + r1 = int32(v8) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -125028,27 +125028,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v20 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v21 = int64(fd) - v22 = int64(level) - v23 = int64(optname) - v24 = int64(optval) - v25 = Int64FromUint32(optlen) - v26 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = Int64FromUint32(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v27 = r + v8 = r goto _28 } - v27 = r + v8 = r goto _28 _28: - r1 = int32(v27) + r1 = int32(v8) break } } @@ -125328,18 +125328,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125354,14 +125354,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]int8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125383,11 +125383,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -125427,11 +125427,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -125445,12 +125445,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -125463,11 +125463,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -125492,14 +125492,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -125561,9 +125561,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -125576,7 +125576,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -125693,7 +125693,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -125705,13 +125705,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -125732,32 +125732,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -125769,12 +125769,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -125794,21 +125794,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -125831,8 +125831,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -125845,7 +125845,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -125889,7 +125889,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -125917,7 +125917,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -125928,17 +125928,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -125953,18 +125953,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -125987,18 +125987,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126013,11 +126013,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]int8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -126039,11 +126039,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]int8)(unsafe.Pointer(bp + 44)) = [11]int8{} @@ -126095,11 +126095,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126263,7 +126263,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126277,10 +126277,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126301,57 +126301,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v10)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v14)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126419,10 +126419,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -126508,7 +126508,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -126523,15 +126523,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -126934,7 +126934,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -127006,8 +127006,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -127017,14 +127017,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127080,7 +127080,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127096,7 +127096,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127124,7 +127124,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127140,7 +127140,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127168,7 +127168,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127184,7 +127184,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127214,11 +127214,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1378) seen_eacces = 0 @@ -127245,7 +127245,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } @@ -127265,9 +127265,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -127750,7 +127750,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -127758,12 +127758,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -127772,12 +127772,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -127786,7 +127786,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -127839,22 +127839,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -127872,15 +127872,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = int32(*(*int8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -127898,7 +127898,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -127906,7 +127906,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -127914,13 +127914,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { @@ -127934,26 +127934,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127963,8 +127963,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -127989,13 +127989,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128015,18 +128015,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v10))))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128034,7 +128034,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -128044,22 +128044,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128081,7 +128081,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128093,11 +128093,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128107,7 +128107,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -128118,9 +128118,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -128128,7 +128128,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128156,7 +128156,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128168,7 +128168,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128200,7 +128200,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128255,13 +128255,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(144) defer tls.Free(144) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep int8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128273,9 +128273,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128292,8 +128292,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128313,7 +128313,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128322,9 +128322,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -128333,9 +128333,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128349,7 +128349,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 if !(*(*int8)(unsafe.Pointer(pat)) != 0) { @@ -128384,19 +128384,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = int8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 575 + v2 = __ccgo_ts + 575 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128406,9 +128406,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -128446,11 +128446,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*int8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -128496,13 +128496,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 int8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 int8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -128510,16 +128510,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*int8)(unsafe.Pointer(v2)) = 0 } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*int8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1412) + v2 = Xgetenv(tls, __ccgo_ts+1412) } - home = v3 + home = v2 if !(home != 0) { if *(*int8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -128554,20 +128554,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) } if *(*int8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v13))) = 0 + v1 = delim + *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -128641,7 +128641,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -128649,7 +128649,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -128663,7 +128663,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -128679,7 +128679,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -128693,7 +128693,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -128718,7 +128718,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -129114,7 +129114,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129155,7 +129155,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -129165,7 +129165,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129263,7 +129263,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129301,16 +129301,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129323,8 +129323,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129335,16 +129335,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129355,11 +129355,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129408,11 +129408,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]int8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -129437,7 +129437,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if int32(*(*int8)(unsafe.Pointer(s))) == int32('[') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*int8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -129452,21 +129452,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || int32(*(*int8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -129474,7 +129474,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -129482,9 +129482,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129517,11 +129517,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -129534,7 +129534,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -129593,11 +129593,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -129616,13 +129616,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -129635,7 +129635,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -129662,12 +129662,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -129681,7 +129681,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -129704,7 +129704,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -129730,11 +129730,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('['): @@ -129776,7 +129776,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch int32(*(*int8)(unsafe.Pointer(v14))) { case 0: @@ -129790,12 +129790,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -129810,20 +129810,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -129839,7 +129839,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -129848,47 +129848,47 @@ _2: if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -129897,7 +129897,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -129906,7 +129906,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -129950,8 +129950,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -129969,12 +129969,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -129983,7 +129983,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -129991,28 +129991,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -130051,7 +130051,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130075,7 +130075,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130096,24 +130096,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130254,7 +130254,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130314,7 +130314,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130355,7 +130355,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130368,7 +130368,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130386,7 +130386,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130399,7 +130399,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130418,7 +130418,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -130453,13 +130453,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -130467,8 +130467,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -130503,7 +130503,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -130573,20 +130573,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -130670,26 +130670,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -130703,7 +130703,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -130797,7 +130797,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -130819,13 +130819,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -130880,8 +130880,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131120,7 +131120,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131161,7 +131161,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131204,7 +131204,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131221,8 +131221,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131285,7 +131285,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131295,7 +131295,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131305,7 +131305,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131334,7 +131334,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131349,7 +131349,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131360,7 +131360,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -131368,7 +131368,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131394,7 +131394,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131409,7 +131409,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -131417,7 +131417,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -131431,9 +131431,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -131462,7 +131462,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -131470,13 +131470,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -131777,9 +131777,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -131833,7 +131833,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -131848,7 +131848,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -131858,13 +131858,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -131882,7 +131882,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -131903,14 +131903,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -131925,7 +131925,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132108,7 +132108,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132153,7 +132153,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132163,12 +132163,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -132190,7 +132190,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132221,7 +132221,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132233,7 +132233,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132296,7 +132296,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132329,7 +132329,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132370,11 +132370,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132417,7 +132417,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -132469,13 +132469,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132528,44 +132528,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -132576,10 +132576,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -132587,10 +132587,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -132613,7 +132613,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -132636,7 +132636,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -132657,18 +132657,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -132703,7 +132703,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -132752,7 +132752,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -132783,7 +132783,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -132807,7 +132807,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -132888,13 +132888,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132958,7 +132958,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -132969,12 +132969,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -132982,10 +132982,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -133055,7 +133055,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133105,7 +133105,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133136,21 +133136,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133161,18 +133161,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133243,7 +133243,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133271,9 +133271,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133300,7 +133300,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133356,8 +133356,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133380,7 +133380,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133396,23 +133396,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -133567,7 +133567,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -133638,7 +133638,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -133661,7 +133661,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -133689,8 +133689,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -133733,8 +133733,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -133790,11 +133790,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -133873,7 +133873,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -133905,7 +133905,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -133926,9 +133926,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -133937,11 +133937,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -133950,9 +133950,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -133961,14 +133961,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -133978,13 +133978,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134125,17 +134125,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134145,9 +134145,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -134162,15 +134162,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134317,8 +134317,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -134551,11 +134551,11 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) bp := tls.Alloc(80) defer tls.Free(80) var r int32 - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 int64 var _ /* ksa at bp+8 */ Tk_sigaction var _ /* ksa_old at bp+40 */ Tk_sigaction - _, _, _, _, _, _ = r, v1, v2, v3, v4, v5 + _, _, _, _ = r, v1, v2, v3 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -134600,24 +134600,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old uintptr) (r1 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Fflags |= uint64(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { - v3 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v3 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Frestorer = v3 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 8))).Frestorer = v1 Xmemcpy(tls, bp+8+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v4 = bp + 8 + v1 = bp + 8 } else { - v4 = uintptr(0) + v1 = uintptr(0) } if old != 0 { - v5 = bp + 40 + v3 = bp + 40 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v4), int64(v5), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 40))).Fhandler (*Tsigaction)(unsafe.Pointer(old)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 40))).Fflags) @@ -134719,7 +134719,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -134795,7 +134795,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -134834,7 +134834,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135170,7 +135170,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -135338,7 +135338,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -135541,7 +135541,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r goto _1 _1: ; - i++ + i = i + 1 } } r = int32(X__syscall3(tls, int64(SYS_futimesat), int64(fd), int64(path), int64(tv))) @@ -135650,19 +135650,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -135707,7 +135707,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -135816,13 +135816,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -135844,12 +135844,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -135873,11 +135873,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -135886,11 +135886,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -135920,9 +135920,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -135936,9 +135936,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -135959,8 +135959,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -135971,9 +135971,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136142,8 +136142,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136152,9 +136152,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -136225,7 +136225,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136338,16 +136338,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -136361,7 +136361,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136375,11 +136375,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136400,9 +136400,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -136418,9 +136418,9 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r int32) { - var c, v1, v11, v12, v2, v4, v7, v8 int32 + var c, v1, v2, v4, v7, v8 int32 var v10, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _ = c, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = c, v1, v10, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -136436,32 +136436,32 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 - v7 = 0 + c = v1 + v2 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1525) - v8 = v7 + v4 = v2 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { + if v4&int32(MAYBE_WAITERS) != 0 { v10 = f + 140 - v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + v7 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v7 < Int32FromInt32(0) { + v7 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v11)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v11)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v7)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v7)) != 0 } return c } @@ -136480,7 +136480,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -136503,9 +136503,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136516,21 +136516,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -136567,13 +136567,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136592,7 +136592,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*int8)(unsafe.Pointer(s)) = 0 return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -136610,8 +136610,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -136619,24 +136619,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = int8(c) - v9 = p - p++ - *(*int8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v6)) = v8 if int32(v8) == int32('\n') { break } @@ -136683,7 +136683,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -136773,22 +136773,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -136806,7 +136806,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -136816,11 +136816,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -136934,7 +136934,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137097,11 +137097,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -137115,8 +137115,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137128,10 +137128,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137143,9 +137143,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -137273,10 +137273,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v12, v13, v2, v4, v8, v9 int32 - var v11, v6, v7 uintptr + var v1, v2, v4, v8 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _ = v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _ = v1, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -137293,33 +137293,33 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = 0 + c = v1 + v1 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1538) - v9 = v8 + v2 = v1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 140 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v4 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v4)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v4)) != 0 } return c } @@ -137341,7 +137341,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -137399,7 +137399,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -137529,8 +137529,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -137554,8 +137554,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -137563,11 +137563,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137577,8 +137577,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137622,7 +137622,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -137689,8 +137689,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -137698,7 +137698,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -137718,9 +137718,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137797,10 +137797,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -137907,10 +137907,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var owner, tid, v1, v2, v3 int32 + var owner, tid, v1, v2 int32 var self Tpthread_t var v5 bool - _, _, _, _, _, _, _ = owner, self, tid, v1, v2, v3, v5 + _, _, _, _, _, _ = owner, self, tid, v1, v2, v5 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -137918,7 +137918,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -137927,17 +137927,17 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { AtomicStorePInt32(f+140, v1) } if v5 = owner != 0; !v5 { - v2 = 0 + v1 = 0 // __asm__ __volatile__ ( // // "lock ; cmpxchg %3, %1" // : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1577) - v3 = v2 + v2 = v1 goto _4 _4: } - if v5 || v3 != 0 { + if v5 || v2 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -137953,7 +137953,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -137962,9 +137962,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137987,11 +137987,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138039,15 +138039,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138117,9 +138117,9 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r int32) { - var c, v1, v11, v12, v2, v4, v7, v8 int32 + var c, v1, v2, v4, v7, v8 int32 var v10, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _ = c, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = c, v1, v10, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -138135,32 +138135,32 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 - v7 = 0 + c = v1 + v2 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1525) - v8 = v7 + v4 = v2 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { + if v4&int32(MAYBE_WAITERS) != 0 { v10 = f + 140 - v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + v7 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v7 < Int32FromInt32(0) { + v7 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v11)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v11)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v7)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v7)) != 0 } return c } @@ -138179,7 +138179,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138212,7 +138212,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -138237,9 +138237,9 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r int32) { - var c, v1, v11, v12, v2, v4, v7, v8 int32 + var c, v1, v2, v4, v7, v8 int32 var v10, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _ = c, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = c, v1, v10, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -138255,32 +138255,32 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 - v7 = 0 + c = v1 + v2 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1525) - v8 = v7 + v4 = v2 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { + if v4&int32(MAYBE_WAITERS) != 0 { v10 = f + 140 - v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + v7 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v7 < Int32FromInt32(0) { + v7 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v11)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v11)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v7)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v10), int64(Int32FromInt32(FUTEX_WAKE)), int64(v7)) != 0 } return c } @@ -138299,7 +138299,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138324,7 +138324,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138337,12 +138337,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 int8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138378,7 +138378,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -138405,7 +138405,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -138413,14 +138413,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138432,14 +138432,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break @@ -138491,7 +138491,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138502,7 +138502,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) } *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 @@ -138681,17 +138681,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138707,9 +138707,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*int8)(unsafe.Pointer(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138825,17 +138825,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138851,9 +138851,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138944,10 +138944,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v12, v13, v2, v4, v8, v9 int32 - var v11, v6, v7 uintptr + var v1, v2, v4, v8 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _ = v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _ = v1, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -138964,33 +138964,33 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = 0 + c = v1 + v1 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1538) - v9 = v8 + v2 = v1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 140 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v4 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v4)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v4)) != 0 } return c } @@ -139012,7 +139012,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139048,7 +139048,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139074,10 +139074,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { - var v1, v12, v13, v2, v4, v8, v9 int32 - var v11, v6, v7 uintptr + var v1, v2, v4, v8 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _ = v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _ = v1, v2, v4, v5, v6, v7, v8 v1 = 0 // __asm__ __volatile__ ( // @@ -139094,33 +139094,33 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = 0 + c = v1 + v1 = 0 // __asm__ __volatile__( // // "xchg %0, %1" // : "=r"(v), "=m"(*p) : "0"(v) : "memory" ); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 22, __ccgo_ts+1538) - v9 = v8 + v2 = v1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 140 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v4 = int32(1) + v8 = int32(1) + if v8 != 0 { + v8 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v8), int64(v4)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v4)) != 0 } return c } @@ -139142,7 +139142,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139170,7 +139170,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139200,7 +139200,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -139536,7 +139536,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139571,7 +139571,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139607,7 +139607,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139641,7 +139641,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -139658,12 +139658,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -139680,10 +139680,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139692,13 +139692,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -139974,7 +139974,7 @@ func _pad3(tls *TLS, f uintptr, c int8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -139988,13 +139988,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140006,45 +140006,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = Int8FromUint64(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -140059,13 +140059,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]int8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140074,7 +140074,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]int8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1603 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -140087,21 +140087,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*int8)(unsafe.Pointer(v10)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v11)) = int8(v12) - estr-- - v13 = estr - *(*int8)(unsafe.Pointer(v13)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*int8)(unsafe.Pointer(v14)) = int8(int32(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*int8)(unsafe.Pointer(v15)) = int8('.') + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140213,46 +140213,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -140268,22 +140268,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -140302,21 +140302,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -140328,8 +140328,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -140339,10 +140339,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -140350,15 +140350,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -140370,23 +140370,23 @@ _4: } } if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -140397,8 +140397,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -140417,14 +140417,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -140438,8 +140438,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -140463,21 +140463,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -140490,31 +140490,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*int8)(unsafe.Pointer(v43)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v44)) = int8(v45) - estr-- - v46 = estr - *(*int8)(unsafe.Pointer(v46)) = int8(t) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140538,15 +140538,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*int8)(unsafe.Pointer(v48)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*int8)(unsafe.Pointer(v49)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140564,21 +140564,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*int8)(unsafe.Pointer(v51)) = int8('0') + s3 = s3 - 1 + v5 = s3 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, int8('0'), p+int32(9), int32(9), 0) } else { @@ -140592,30 +140592,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*int8)(unsafe.Pointer(v54)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*int8)(unsafe.Pointer(v55)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+575, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -140627,11 +140627,11 @@ _4: } _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -140650,7 +140650,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -140658,19 +140658,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]int8 var _ /* mb at bp+48 */ [4]int8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -140683,7 +140683,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -140696,7 +140696,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -140706,8 +140706,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140722,10 +140722,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -140733,11 +140733,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -140749,7 +140749,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -140758,19 +140758,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -140783,16 +140783,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -140800,7 +140800,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140816,7 +140816,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -140855,11 +140855,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -140935,14 +140935,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -140968,10 +140968,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -140986,7 +140986,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -141004,12 +141004,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*int8)(unsafe.Pointer(v35)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141023,24 +141023,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1644 + v8 = __ccgo_ts + 1644 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141054,23 +141054,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -141083,28 +141083,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, int8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141169,7 +141169,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141178,7 +141178,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -141204,12 +141204,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -141248,11 +141248,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -141306,7 +141306,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -141320,17 +141320,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -141353,99 +141353,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -141456,33 +141456,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -141536,14 +141536,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -141561,85 +141561,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -141653,10 +141653,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -141664,11 +141664,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -141680,36 +141680,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -141722,16 +141722,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -141742,12 +141742,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -141766,23 +141766,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v73))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -141791,40 +141791,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v79))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141832,7 +141832,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -141855,26 +141855,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -141889,15 +141889,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -141906,6 +141898,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -141921,20 +141921,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -141946,7 +141946,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -141955,7 +141955,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142127,7 +142127,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142184,7 +142184,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -142192,7 +142192,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]int8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -142205,7 +142205,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -142229,7 +142229,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142244,7 +142244,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -142255,7 +142255,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) goto _4 _4: ; @@ -142267,7 +142267,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -142282,13 +142282,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -142297,16 +142297,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -142362,7 +142362,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -142404,11 +142404,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -142429,27 +142429,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1644 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -142464,13 +142464,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -142522,7 +142522,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142531,7 +142531,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -142623,7 +142623,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142666,7 +142666,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -142687,14 +142687,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -142719,23 +142719,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142746,37 +142746,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142785,7 +142785,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -142795,7 +142795,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -142806,8 +142806,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -142820,9 +142820,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -142894,45 +142894,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142959,8 +142959,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -142979,17 +142979,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -142997,11 +142997,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -143016,27 +143016,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143046,17 +143046,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143065,16 +143065,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143132,23 +143132,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1687, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1705, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143156,7 +143156,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143168,7 +143168,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143177,7 +143177,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143258,8 +143258,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143273,11 +143273,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -143398,11 +143398,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -143420,9 +143420,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -143436,9 +143436,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -143483,9 +143483,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -143503,10 +143503,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -143625,9 +143625,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -143638,27 +143638,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -143680,19 +143680,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143722,19 +143722,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143759,11 +143759,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -143790,9 +143790,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]int8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -143809,9 +143809,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = 0 *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -143987,9 +143987,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -143998,7 +143998,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -144009,7 +144009,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -144021,10 +144021,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144035,16 +144035,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144075,12 +144075,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144127,13 +144127,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -144149,17 +144149,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -144167,7 +144167,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -144198,9 +144198,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -144210,11 +144210,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144387,7 +144387,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144395,7 +144395,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144406,11 +144406,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144431,11 +144431,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144491,7 +144491,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144499,7 +144499,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144510,11 +144510,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144535,11 +144535,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144649,9 +144649,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -144667,9 +144667,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -144685,7 +144685,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -144693,19 +144693,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -144744,8 +144744,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -144758,7 +144758,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -144769,8 +144769,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -144797,9 +144797,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -144817,9 +144817,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -144827,14 +144827,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -144848,32 +144848,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -144884,22 +144884,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -144915,23 +144915,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -144947,18 +144947,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -144974,170 +144974,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145147,27 +145147,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145309,29 +145309,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145366,22 +145366,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145389,10 +145389,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -145405,12 +145405,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145440,7 +145440,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -145465,9 +145465,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145480,14 +145480,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) } for { @@ -145498,42 +145498,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = *(*int8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } } @@ -145560,7 +145560,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -145618,9 +145618,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -145651,8 +145651,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -145668,8 +145668,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -145699,8 +145699,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 int8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 int8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -145714,8 +145714,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -145736,16 +145736,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -145784,9 +145784,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 int8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 int8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -145799,9 +145799,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { goto tail @@ -145816,7 +145816,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145824,19 +145824,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145878,8 +145878,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -145918,7 +145918,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -145981,7 +145981,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -146002,7 +146002,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146036,8 +146036,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146058,10 +146058,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int64(a)) @@ -146069,16 +146069,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -146087,7 +146087,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146169,12 +146169,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 int8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 int8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146190,9 +146190,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146205,7 +146205,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146214,19 +146214,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*int8)(unsafe.Pointer(d)) = 0 goto finish @@ -146265,7 +146265,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146285,7 +146285,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146301,7 +146301,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146312,9 +146312,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146340,21 +146340,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*int8)(unsafe.Pointer(v3)) = 0 + v1 = d + d = d + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 return a } @@ -146369,7 +146369,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146380,9 +146380,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146438,7 +146438,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*int8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146469,7 +146469,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { end = uintptr(0) @@ -146495,7 +146495,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -146506,12 +146506,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -146523,10 +146523,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*int8)(unsafe.Pointer(c)) != 0) { @@ -146540,22 +146540,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -146564,18 +146564,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146707,29 +146707,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146766,7 +146766,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -146776,22 +146776,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146799,10 +146799,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -146815,12 +146815,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -146868,9 +146868,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -146878,17 +146878,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v1 = _p2 + _p2 = _p2 + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { _p2 = uintptr(0) } @@ -146902,9 +146902,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -146912,18 +146912,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -146966,7 +146966,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -146982,7 +146982,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147011,12 +147011,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -147216,7 +147216,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147229,7 +147229,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -147247,21 +147247,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -147279,7 +147279,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147305,7 +147305,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147337,7 +147337,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147392,10 +147392,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -147405,7 +147405,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147419,23 +147419,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147444,29 +147444,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147503,16 +147503,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -147520,10 +147520,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -147536,12 +147536,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -147577,9 +147577,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147587,18 +147587,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147627,7 +147627,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -147652,7 +147652,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147680,7 +147680,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147699,8 +147699,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -147708,7 +147708,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147716,9 +147716,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -147742,7 +147742,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147775,7 +147775,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147800,27 +147800,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1747, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147883,7 +147883,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148094,7 +148094,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148145,38 +148145,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148184,15 +148184,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(int32(_days_in_month[months]) <= remdays) { break } - remdays -= int32(_days_in_month[months]) + remdays = remdays - int32(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148238,19 +148238,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148287,7 +148287,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148297,20 +148297,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148329,21 +148329,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148354,7 +148354,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148366,10 +148366,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148383,7 +148383,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148409,13 +148409,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148425,13 +148425,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]int8 var _ /* dummy_name at bp+308 */ [7]int8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1754) @@ -148455,7 +148455,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148469,7 +148469,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -148494,7 +148494,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1757) != 0) { @@ -148516,7 +148516,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -148543,7 +148543,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -148560,16 +148560,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -148589,7 +148589,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -148624,11 +148624,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148666,10 +148666,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -148698,7 +148698,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -148749,25 +148749,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -148810,16 +148810,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -148892,7 +148892,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -148909,8 +148909,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -148920,15 +148920,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -148938,11 +148938,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149339,9 +149339,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -149369,9 +149369,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149382,7 +149382,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149391,7 +149391,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149415,10 +149415,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1679 width = int32(2) def_pad = int32('0') @@ -149472,14 +149472,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -149496,7 +149496,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -149527,11 +149527,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -149540,14 +149540,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -149571,11 +149571,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -149635,11 +149635,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1883, VaList(bp+8, val))) case int32('_'): @@ -149681,15 +149681,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]int8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -149701,21 +149701,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = int32(*(*int8)(unsafe.Pointer(v3))) } v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -149732,7 +149732,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -149743,8 +149743,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -149753,8 +149753,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -149767,50 +149767,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v7))) = int8('-') - width-- + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v10))) = int8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v12))) = int8('0') + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -149844,15 +149844,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -149876,21 +149876,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -149900,7 +149900,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch int32(*(*int8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -149997,7 +149997,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150052,19 +150052,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*int8)(unsafe.Pointer(s)) != 0; v48 { - v45 = int32(*(*int8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { + v1 = int32(*(*int8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150076,7 +150076,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150084,7 +150084,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150148,7 +150148,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150161,9 +150161,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if int32(*(*int8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150182,13 +150182,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150203,30 +150203,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150246,13 +150246,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -150451,7 +150451,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -150459,7 +150459,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -150471,7 +150471,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -150517,40 +150517,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -150703,8 +150703,8 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { trc("tls=%v old=%v new1=%v flags=%v, (%v:)", tls, old, new1, flags, origin(2)) defer func() { trc("-> %v", r1) }() } - var r, v1, v2 int32 - _, _, _ = r, v1, v2 + var r, v1 int32 + _, _ = r, v1 if old == new1 { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } @@ -150724,9 +150724,9 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) - r = v2 - if !(v2 == -int32(EBUSY)) { + v1 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) + r = v1 + if !(v1 == -int32(EBUSY)) { break } } @@ -150958,7 +150958,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*int8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = 0 @@ -151111,7 +151111,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_arm.go b/vendor/modernc.org/libc/ccgo_linux_arm.go index 311fbcc..dd1c182 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm.go @@ -644,14 +644,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -660,8 +660,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -993,18 +993,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -1036,9 +1036,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int32(t) /* the multiple */ t = float64(i) @@ -1088,9 +1088,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int32(t) /* the multiple */ t = float32(i) @@ -1134,18 +1134,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1153,18 +1153,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1223,8 +1223,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1245,42 +1245,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1294,11 +1294,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1308,17 +1308,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1329,11 +1329,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1346,17 +1346,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1369,11 +1369,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1385,8 +1385,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1402,92 +1402,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1520,14 +1520,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1541,32 +1541,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1585,11 +1585,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1604,12 +1604,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1621,32 +1621,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1665,11 +1665,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1937,18 +1937,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1956,18 +1956,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1980,8 +1980,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2002,42 +2002,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -2051,11 +2051,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2064,17 +2064,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2085,11 +2085,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2104,17 +2104,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2127,11 +2127,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2143,8 +2143,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2160,92 +2160,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2289,14 +2289,14 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2311,29 +2311,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2364,8 +2364,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2373,22 +2373,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2410,13 +2410,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2431,29 +2431,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2461,21 +2461,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2489,18 +2489,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2523,18 +2523,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2542,18 +2542,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2564,16 +2564,16 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2616,15 +2616,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2667,11 +2667,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2681,15 +2681,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2714,50 +2714,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7641,12 +7641,12 @@ func Xsysconf(tls *TLS, name int32) (r int32) { bp := tls.Alloc(464) defer tls.Free(464) var cnt, i, val, v3 int32 - var mem, v1, v6 uint64 - var p5 uintptr + var mem, v1 uint64 + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint32FromInt32(name) >= Uint32FromInt64(502)/Uint32FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) @@ -7702,14 +7702,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return cnt case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7724,14 +7724,14 @@ func Xsysconf(tls *TLS, name int32) (r int32) { } else { mem = uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram) } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= uint64(X__libc.Fpage_size) + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / uint64(X__libc.Fpage_size) if mem > uint64(0x7fffffff) { - v6 = uint64(0x7fffffff) + v1 = uint64(0x7fffffff) } else { - v6 = mem + v1 = mem } - return Int32FromUint64(v6) + return Int32FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7740,7 +7740,7 @@ func Xsysconf(tls *TLS, name int32) (r int32) { val = int32(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int32(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int32(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -9116,16 +9116,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9134,10 +9134,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9146,16 +9146,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9164,16 +9164,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9182,58 +9182,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9253,7 +9253,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9264,12 +9264,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9277,36 +9277,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9314,9 +9314,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9325,10 +9325,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9375,9 +9375,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9394,25 +9394,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9423,11 +9423,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9452,7 +9452,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9465,7 +9465,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9482,13 +9482,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9501,7 +9501,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9526,7 +9526,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9534,7 +9534,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9553,9 +9553,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9564,7 +9564,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } _memcpy(tls, output, setting, Uint32FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] @@ -11447,7 +11447,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11474,14 +11474,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11491,8 +11491,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11527,35 +11527,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11568,10 +11568,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11585,19 +11585,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11608,7 +11608,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11624,10 +11624,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11636,7 +11636,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11646,23 +11646,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11693,12 +11693,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11708,10 +11708,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11731,11 +11731,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11750,11 +11750,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11766,12 +11766,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11981,7 +11981,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11989,60 +11989,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12055,7 +12055,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint32(64)-r) @@ -12099,7 +12099,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12116,8 +12116,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } _memcpy(tls, s+24+uintptr(r), p, uint32(64)-r) - len1 -= uint32(64) - r - p += uintptr(uint32(64) - r) + len1 = len1 - (uint32(64) - r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -12128,8 +12128,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(64) - p += uintptr(64) + len1 = len1 - uint32(64) + p = p + uintptr(64) } _memcpy(tls, s+24, p, len1) } @@ -12169,15 +12169,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12208,7 +12208,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12230,7 +12230,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _2 _2: ; - i -= uint32(16) + i = i - uint32(16) } _md5_update(tls, bp, bp+88, i) (*(*[16]uint8)(unsafe.Pointer(bp + 88)))[0] = uint8(0) @@ -12247,7 +12247,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12277,13 +12277,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ _memcpy(tls, output, setting, uint32(3)+slen) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v5)) = uint8('$') i = uint32(0) for { @@ -12294,7 +12294,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -12495,7 +12495,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12505,7 +12505,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12533,7 +12533,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12550,7 +12550,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint32(64)-r) @@ -12598,7 +12598,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12615,8 +12615,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } _memcpy(tls, s+40+uintptr(r), p, uint32(64)-r) - len1 -= uint32(64) - r - p += uintptr(uint32(64) - r) + len1 = len1 - (uint32(64) - r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12627,8 +12627,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(64) - p += uintptr(64) + len1 = len1 - uint32(64) + p = p + uintptr(64) } _memcpy(tls, s+40, p, len1) } @@ -12640,15 +12640,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12672,7 +12672,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, i) } @@ -12714,7 +12714,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint32FromInt64(8) - Uint32FromInt32(1)) + salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12747,7 +12747,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12774,7 +12774,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12788,7 +12788,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12802,7 +12802,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12832,11 +12832,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+232, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+232, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12846,7 +12846,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint32(128)-r) @@ -13157,7 +13157,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -13174,8 +13174,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { return } _memcpy(tls, s+72+uintptr(r), p, uint32(128)-r) - len1 -= uint32(128) - r - p += uintptr(uint32(128) - r) + len1 = len1 - (uint32(128) - r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -13186,8 +13186,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint32) { goto _1 _1: ; - len1 -= uint32(128) - p += uintptr(128) + len1 = len1 - uint32(128) + p = p + uintptr(128) } _memcpy(tls, s+72, p, len1) } @@ -13199,15 +13199,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13231,7 +13231,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, i) } @@ -13258,7 +13258,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13283,7 +13283,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint32FromInt64(8) - Uint32FromInt32(1)) + salt = salt + uintptr(Uint32FromInt64(8)-Uint32FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13316,7 +13316,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13343,7 +13343,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13357,7 +13357,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13371,7 +13371,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13401,11 +13401,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+424, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+424, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13415,7 +13415,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -13563,9 +13563,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13577,18 +13577,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17713,8 +17713,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint32(0) } @@ -22431,7 +22431,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22470,10 +22470,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22539,15 +22539,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22558,15 +22558,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -25144,10 +25144,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint32(0) @@ -25182,16 +25182,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 _memcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*4)), de, uint32((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint32(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint32(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*4))) @@ -25261,7 +25261,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25374,7 +25374,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 4 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25476,7 +25476,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25488,7 +25488,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*4)) = new1 } @@ -25933,7 +25933,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25957,7 +25957,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -26001,7 +26001,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint32(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint32(O_LARGEFILE) + arg = arg | uint32(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_fcntl64), fd, cmd, int32(uintptr(arg)), 0, 0, 0))) @@ -26186,15 +26186,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26203,23 +26203,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 4 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26229,18 +26229,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 4 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26248,58 +26248,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 4 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26324,7 +26324,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26334,32 +26334,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 4 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 4 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26375,7 +26375,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26384,15 +26384,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26403,14 +26403,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26420,7 +26420,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26428,11 +26428,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26464,12 +26464,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26494,19 +26494,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26519,24 +26519,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26597,7 +26597,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26608,11 +26608,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26624,29 +26624,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26659,40 +26659,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26719,11 +26719,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26737,7 +26737,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26753,26 +26753,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 4 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26784,15 +26784,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 4 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26816,41 +26816,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 4 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 4 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26862,15 +26862,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26880,10 +26880,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26897,13 +26897,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26915,11 +26915,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26931,10 +26931,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26953,7 +26953,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26969,16 +26969,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint32(0) for { @@ -26987,24 +26987,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint32(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 4 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint32(3) || i == uint32(8) || i > uint32(3) && pok != 0 { if i != uint32(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -27012,12 +27012,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -27031,55 +27031,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint32(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 4 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint32(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 4 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint32(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 4 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27087,26 +27087,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27114,19 +27114,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 4 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27400,11 +27400,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27415,7 +27415,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27433,42 +27433,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 4 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 4 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27487,7 +27487,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27501,18 +27501,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 4 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27520,18 +27520,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 4 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 4 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27545,18 +27545,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27679,7 +27679,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') @@ -27694,21 +27694,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27751,7 +27751,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28126,9 +28126,9 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v4 uintptr + var v3 uintptr var v5 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v5 if ts != 0 { v1 = (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec } else { @@ -28167,11 +28167,11 @@ func Xsemtimedop(tls *TLS, id int32, buf uintptr, n Tsize_t, ts uintptr) (r1 int 0: int32(Int32FromUint64(v5)), 1: ns, } - v4 = bp + 16 + v3 = bp + 16 } else { - v4 = uintptr(0) + v3 = uintptr(0) } - ts = v4 + ts = v3 return X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_semtimedop), id, int32(buf), Int32FromUint32(n), int32(ts)))) } @@ -28601,7 +28601,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28808,7 +28808,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint32(128)) if l >= 0 { if l > 0 && Int32FromUint8(_password[l-int32(1)]) == int32('\n') || Uint32FromInt32(l) == uint32(128) { - l-- + l = l - 1 } _password[l] = uint8(0) } @@ -29307,7 +29307,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = int64((*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int32FromInt32(1000000)) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30549,7 +30549,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return X__syscall_ret(tls, Uint32FromInt32(X__syscall5(tls, int32(SYS_prctl), op, Int32FromUint32(x[0]), Int32FromUint32(x[int32(1)]), Int32FromUint32(x[int32(2)]), Int32FromUint32(x[int32(3)])))) @@ -31586,8 +31586,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if n >= size/uint32(4) || o >= size-uint32(4)*n || t >= size-uint32(4)*n || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31607,10 +31607,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31699,10 +31699,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint32(1)) + trans = trans + uintptr(l+uint32(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98575,7 +98575,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98583,8 +98583,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98608,16 +98608,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint32(1)) + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) } return Uint32FromInt32(int32(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint32(1)) + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98684,23 +98684,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98741,10 +98741,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98762,10 +98762,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(48) defer tls.Free(48) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+40 */ uintptr var _ /* st at bp+16 */ Tmbstate_t @@ -98775,7 +98775,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+44 */ [4]uint8 var _ /* wc at bp+24 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint32(0) scd = uintptr(0) if !(uint32(cd)&Uint32FromInt32(1) != 0) { @@ -98963,11 +98963,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint32(4) } @@ -98980,7 +98980,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint32(2) @@ -98989,27 +98989,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -99035,11 +99035,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -99098,8 +99098,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -99112,7 +99112,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -99136,7 +99136,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -99161,13 +99161,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -99185,28 +99185,28 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) - c += k + c = c + k goto _29 _29: } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -99223,18 +99223,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -99306,7 +99306,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -99324,20 +99324,20 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) - c += k + c = c + k goto _32 _32: } @@ -99425,7 +99425,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -99445,7 +99445,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*uint8)(unsafe.Pointer(v54)) = uint8(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(1) goto _51 @@ -99463,7 +99463,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99472,17 +99472,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99494,24 +99494,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v57)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v60)) = uint8(v62) + *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) goto _51 _40: @@ -99520,7 +99520,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99530,14 +99530,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*uint8)(unsafe.Pointer(v63)) = uint8(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*uint8)(unsafe.Pointer(v65)) = uint8(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(2) goto _51 _41: @@ -99549,56 +99549,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*uint8)(unsafe.Pointer(v67)) = uint8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*uint8)(unsafe.Pointer(v69)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*uint8)(unsafe.Pointer(v71)) = uint8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*uint8)(unsafe.Pointer(v73)) = uint8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*uint8)(unsafe.Pointer(v75)) = uint8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*uint8)(unsafe.Pointer(v77)) = uint8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*uint8)(unsafe.Pointer(v79)) = uint8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*uint8)(unsafe.Pointer(v81)) = uint8(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*uint8)(unsafe.Pointer(v83)) = uint8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*uint8)(unsafe.Pointer(v85)) = uint8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*uint8)(unsafe.Pointer(v87)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(7) goto _51 } @@ -99609,38 +99609,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*uint8)(unsafe.Pointer(v89)) = uint8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*uint8)(unsafe.Pointer(v91)) = uint8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*uint8)(unsafe.Pointer(v93)) = uint8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*uint8)(unsafe.Pointer(v95)) = uint8(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*uint8)(unsafe.Pointer(v97)) = uint8(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*uint8)(unsafe.Pointer(v99)) = uint8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*uint8)(unsafe.Pointer(v101)) = uint8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*uint8)(unsafe.Pointer(v103)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint32(8) goto _51 _42: @@ -99671,7 +99671,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint32(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99748,8 +99748,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99763,11 +99763,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4)) + 8 } else { - v2 = __ccgo_ts + 447 + v1 = __ccgo_ts + 447 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99804,13 +99804,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*4))) @@ -99879,11 +99879,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]uint8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*uint8)(unsafe.Pointer(val)) != 0) { @@ -99912,7 +99912,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 456 @@ -99980,11 +99980,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint32(36)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint32(36)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size _memcpy(tls, new1+8, val, n) @@ -100088,7 +100088,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -100116,7 +100116,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -100193,7 +100193,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -100204,7 +100204,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100314,7 +100314,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -100328,7 +100328,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint32 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -100372,7 +100372,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint32 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100428,10 +100428,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(48) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+24 */ [24]uint8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100467,7 +100467,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100480,7 +100480,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(i)*4)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 8 @@ -100491,22 +100491,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) _memcpy(tls, s, part1, l) *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') - s += uintptr(l + uint32(1)) + s = s + uintptr(l+uint32(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + s = s - 1 + v3 = s + *(*uint8)(unsafe.Pointer(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100519,11 +100519,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 32 + uintptr(cat)*4)) } if lm != 0 { - v6 = lm + 8 + v3 = lm + 8 } else { - v6 = __ccgo_ts + 447 + v3 = __ccgo_ts + 447 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100557,9 +100557,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100573,15 +100573,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100593,9 +100593,9 @@ _4: for { switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100616,7 +100616,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100627,13 +100627,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100642,12 +100642,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100656,12 +100656,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100672,8 +100672,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return -int32(1) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100868,9 +100868,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 32 @@ -100883,11 +100883,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -101087,13 +101087,13 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { F__ccgo_align [0]uint32 Fi [0]Tuint64_t @@ -101115,11 +101115,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101503,12 +101503,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101633,10 +101633,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101664,8 +101664,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101679,17 +101679,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101709,18 +101709,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101733,7 +101733,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101752,7 +101752,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101766,7 +101766,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101778,11 +101778,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101793,7 +101793,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101807,37 +101807,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101851,11 +101851,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101869,17 +101869,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101901,18 +101901,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101924,38 +101924,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101971,7 +101971,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101987,7 +101987,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101995,11 +101995,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -102065,13 +102065,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -102231,12 +102231,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -102278,11 +102278,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102941,11 +102941,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102960,7 +102960,7 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { @@ -102968,7 +102968,7 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -103046,11 +103046,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -103163,11 +103163,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -103303,11 +103303,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -103866,7 +103866,7 @@ func Xcos(tls *TLS, x3 float64) (r float64) { var _ /* y at bp+0 */ [2]float64 _, _, _, _, _ = ix, n, y, y1, y2 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103924,12 +103924,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103965,11 +103965,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -104246,7 +104246,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -104281,12 +104281,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -104313,11 +104313,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -104431,7 +104431,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -104466,12 +104466,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104498,11 +104498,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104538,11 +104538,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104629,13 +104629,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104831,11 +104831,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits -= Uint64FromUint64(1) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104911,14 +104911,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104926,13 +104926,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104986,9 +104986,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -105013,13 +105013,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -105120,13 +105120,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -105265,7 +105265,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -105343,7 +105343,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -105400,7 +105400,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -105503,14 +105503,14 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105519,10 +105519,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105540,13 +105540,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105555,10 +105555,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105779,7 +105779,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105791,10 +105791,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix &= Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105906,7 +105906,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) if v1>>Int32FromInt32(32) != 0 { v2 = _a_clz_32(tls, uint32(v1>>int32(32))) @@ -105920,15 +105920,15 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>Int32FromInt32(32) != 0 { - v5 = _a_clz_32(tls, uint32(v4>>int32(32))) + v1 = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + if v1>>Int32FromInt32(32) != 0 { + v2 = _a_clz_32(tls, uint32(v1>>int32(32))) goto _6 } - v5 = _a_clz_32(tls, uint32(v4)) + int32(32) + v2 = _a_clz_32(tls, uint32(v1)) + int32(32) goto _6 _6: - d = v5 - int32(1) + d = v2 - int32(1) if d < 0 { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105939,7 +105939,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { return float64(x1*y) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105972,7 +105972,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) - r += float64(Tdouble_t(tiny*tiny) * (r - r)) + r = r + float64(Tdouble_t(tiny*tiny)*(r-r)) } } else { /* only round once when scaled */ @@ -106005,14 +106005,14 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -106021,27 +106021,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -106049,11 +106049,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -106063,13 +106063,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -106078,27 +106078,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -106106,11 +106106,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -106128,14 +106128,14 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -106144,27 +106144,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -106172,11 +106172,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -106186,13 +106186,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -106201,27 +106201,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -106229,11 +106229,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -106322,13 +106322,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi &= -Uint64FromUint64(1) >> Int32FromInt32(12) - uxi |= Uint64FromUint64(1) << Int32FromInt32(52) + uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + uxi = uxi | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -106379,17 +106379,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _7 _7: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi -= Uint64FromUint64(1) << Int32FromInt32(52) - uxi |= Uint64FromInt32(ex) << int32(52) + uxi = uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106520,17 +106520,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106595,12 +106595,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106624,10 +106624,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p1)) & Uint32FromUint32(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(p2)) | Uint32FromUint32(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) & Uint32FromUint32(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(*(*Tuint32_t)(unsafe.Pointer(v1)) | Uint32FromUint32(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106746,13 +106746,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106827,13 +106827,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint32(4) == uint32(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106899,8 +106899,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106951,7 +106951,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint32(4) == uint32(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106973,8 +106973,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -107070,7 +107070,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -107226,7 +107226,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -107334,7 +107334,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -107414,7 +107414,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107559,7 +107559,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107667,7 +107667,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107758,7 +107758,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107905,7 +107905,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -108012,7 +108012,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -108094,7 +108094,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -108236,7 +108236,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -108343,7 +108343,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -108383,7 +108383,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108397,14 +108397,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -108447,7 +108447,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -108471,12 +108471,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -108489,8 +108489,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108505,7 +108505,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108530,7 +108530,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108543,14 +108543,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108577,15 +108577,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108651,7 +108651,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108661,11 +108661,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108679,7 +108679,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108690,14 +108690,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108711,7 +108711,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108734,12 +108734,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108751,8 +108751,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108767,7 +108767,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108792,7 +108792,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108805,14 +108805,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108838,13 +108838,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108881,7 +108881,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108890,11 +108890,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -109003,8 +109003,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -109113,7 +109113,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -109121,11 +109121,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -109137,20 +109137,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -109264,7 +109264,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -109370,7 +109370,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -109378,11 +109378,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -109394,20 +109394,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109552,9 +109552,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109580,31 +109580,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109717,8 +109717,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109916,7 +109916,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109926,7 +109926,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -110016,7 +110016,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -110026,7 +110026,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -110073,11 +110073,11 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { } var hi, invc, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, y1, z Tdouble_t var i, k int32 - var ix, iz, tmp, v12, v6 Tuint64_t + var ix, iz, tmp, v6 Tuint64_t var top Tuint32_t - var y, v1, v10, v11, v13, v14, v2, v3, v4, v7, v8 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, rhi, rhi1, rlo, rlo1, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5, v6 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -110093,8 +110093,8 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { return Float64FromInt32(0) } r = x1 - float64(1) - v7 = r - v6 = *(*Tuint64_t)(unsafe.Pointer(&v7)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) + v1 = r + v6 = *(*Tuint64_t)(unsafe.Pointer(&v1)) & (-Uint64FromUint64(1) << Int32FromInt32(32)) rhi = *(*float64)(unsafe.Pointer(&v6)) rlo = r - rhi hi = Tdouble_t(rhi * X__log2_data.Finvln2hi) @@ -110104,31 +110104,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v10 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v11 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v11)) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix - Uint64FromUint64(52)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110923,9 +110923,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110982,8 +110982,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110998,7 +110998,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -111027,32 +111027,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -111193,12 +111193,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits -= Uint64FromUint64(1009) << Int32FromInt32(52) + sbits = sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -111285,16 +111285,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -111364,11 +111364,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, lhi, llo, x2, yhi, ylo Tdouble_t var ix, iy, v16, v17 Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v18, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, lhi, llo, sign_bias, topx, topy, x2, y, yhi, yint, ylo, v1, v16, v17, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -111387,19 +111387,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -111413,14 +111413,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -111432,51 +111432,51 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix -= Uint64FromUint64(52) << Int32FromInt32(52) + v1 = float64(x1 * float64(4.503599627370496e+15)) + ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) + ix = ix & uint64(0x7fffffffffffffff) + ix = ix - Uint64FromUint64(52)<> Int32FromInt32(12) - uxi |= Uint64FromUint64(1) << Int32FromInt32(52) + uxi = uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12)) + uxi = uxi | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111917,8 +111917,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _7 _7: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111926,10 +111926,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint64FromUint64(1) << Int32FromInt32(52) - uxi |= Uint64FromInt32(ex) << int32(52) + uxi = uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111937,10 +111937,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -112024,13 +112024,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -112088,8 +112088,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -112097,10 +112097,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -112108,10 +112108,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -112392,14 +112392,14 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -112415,10 +112415,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -112444,13 +112444,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -112466,10 +112466,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -112542,11 +112542,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -112555,11 +112555,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -112586,22 +112586,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112647,12 +112647,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112667,18 +112667,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112710,14 +112710,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112733,18 +112733,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112757,9 +112757,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112805,13 +112805,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112827,18 +112827,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112869,11 +112869,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112889,24 +112889,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112967,13 +112967,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112987,18 +112987,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113029,11 +113029,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -113206,9 +113206,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -113227,7 +113227,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -113236,7 +113236,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -113264,9 +113264,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -113376,7 +113376,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -113411,9 +113411,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -113423,13 +113423,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -113455,11 +113455,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -113474,18 +113474,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint32(8) == uint32(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -113521,13 +113521,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -113541,18 +113541,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint32(4) == uint32(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113569,28 +113569,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113791,8 +113791,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113892,7 +113892,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113905,7 +113905,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113978,7 +113978,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113991,10 +113991,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -114005,7 +114005,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -114155,12 +114155,12 @@ func Xa64l(tls *TLS, s uintptr) (r int32) { if !(d != 0) { break } - x |= Uint32FromInt32(int32(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt32(int32(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*uint8)(unsafe.Pointer(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) @@ -114211,7 +114211,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint32(1))))) != int32('/')) { @@ -114220,7 +114220,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -114254,7 +114254,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -114266,7 +114266,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -114278,7 +114278,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*uint8)(unsafe.Pointer(s + uintptr(i+uint32(1)))) = uint8(0) return s @@ -114472,7 +114472,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint32(0) for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -114487,11 +114487,11 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -114584,17 +114584,17 @@ func Xfmtmsg(tls *TLS, classification int32, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == uint32(':') { @@ -114873,11 +114873,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*4)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*4)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114929,7 +114929,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*4)) = tmp } @@ -114958,7 +114958,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114975,7 +114975,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114983,9 +114983,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4)) + 2)) != 0) { colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -115000,11 +115000,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname opt = start if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -115015,11 +115015,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int32(arg)-int32(start) == Xmblen(tls, start, uint32(MB_LEN_MAX)) { l = int32(arg) - int32(start) @@ -115036,22 +115036,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fval @@ -115077,7 +115077,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+635, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*16))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -115093,13 +115093,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 704 + v5 = __ccgo_ts + 704 } else { - v6 = __ccgo_ts + 611 + v5 = __ccgo_ts + 611 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*4))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -115160,9 +115160,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint32 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = X__syscall_ret(tls, Uint32FromInt32(X__syscall4(tls, int32(SYS_prlimit64), int32(Int32FromInt32(0)), resource, int32(Int32FromInt32(0)), int32(rlim)))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -115185,11 +115185,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)] == -Uint32FromUint32(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) + v1 = uint64((*(*[2]uint32)(unsafe.Pointer(bp)))[int32(1)]) } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -115241,7 +115241,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -115266,7 +115266,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -115557,15 +115557,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { _memcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint32FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint32(8) } else { v2 = uint32(UintptrFromInt32(0) + 8) } align = Int32FromUint32(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { _memcpy(tls, bp, new1+uintptr(new_offset), uint32(8)) *(*int32)(unsafe.Pointer(bp + 8)) = int32(*(*int64)(unsafe.Pointer(bp))) @@ -115575,12 +115575,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = int64(*(*int32)(unsafe.Pointer(bp + 8))) _memcpy(tls, new1+uintptr(new_offset), bp, uint32(8)) } - new_offset = int32(uint32(new_offset) + Uint32FromInt64(8)) - old_offset = int32(uint32(old_offset) + Uint32FromInt64(4)) + new_offset = Int32FromUint32(uint32(new_offset) + Uint32FromInt64(8)) + old_offset = Int32FromUint32(uint32(old_offset) + Uint32FromInt64(4)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { _memcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint32FromInt32(old_size-old_offset)) @@ -115629,7 +115629,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return X__syscall_ret(tls, Uint32FromInt32(r)) @@ -115773,28 +115773,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*uint8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115804,29 +115804,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*uint8)(unsafe.Pointer(v7)) = cval + v1 = dest + dest = dest + 1 + *(*uint8)(unsafe.Pointer(v1)) = cval src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } } *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -115875,7 +115875,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+740, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+16, mnt+20)) } @@ -115935,15 +115935,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(192) defer tls.Free(192) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint32 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+184 */ TFTW var _ /* new at bp+152 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint32(1))))) == int32('/') { v1 = l - uint32(1) @@ -115995,11 +115995,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 152))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 152))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 152))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 152))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 152))).Fbase = Int32FromUint32(j + uint32(1)) (*(*TFTW)(unsafe.Pointer(bp + 184))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 152))).Flevel if h != 0 { @@ -116013,7 +116013,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint32(1))))) != int32('/')) { @@ -116022,7 +116022,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 184))).Fbase = Int32FromUint32(k) } @@ -116037,10 +116037,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+184) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+184) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -116078,9 +116078,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+152) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+152) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -116092,11 +116092,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+184) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+184) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -116269,7 +116269,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(s0)) } @@ -116282,12 +116282,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]uint8 var _ /* stack at bp+0 */ [4097]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint32(0) nup = uint32(0) check_dir = 0 @@ -116322,27 +116322,27 @@ _3: nup = uint32(0) q = uint32(0) v4 = q - q++ + q = q + 1 (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') - p++ + p = p + 1 /* Initial // is special. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint32(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v5] = uint8('/') + v4 = q + q = q + 1 + (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint32FromInt32(int32(z) - int32(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint32FromInt32(int32(z) - int32(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint32(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -116352,17 +116352,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v7] = uint8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + l = l + 1 } if q+l >= uint32(PATH_MAX) { goto toolong } _memcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) - p += l + p = p + l up = 0 if l0 == uint32(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint32(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint32(1)]) == int32('.') { up = int32(1) @@ -116371,8 +116371,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint32(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -116401,23 +116401,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint32(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint32(1) && (q > uint32(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint32(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint32(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -116425,10 +116425,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int32(1)]) == int32('/') { for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint32FromInt32(k) + p = p - Uint32FromInt32(k) Xmemmove(tls, bp+uintptr(p), bp, Uint32FromInt32(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -116436,7 +116436,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -116450,26 +116450,26 @@ _1: /* Cancel any initial .. components. */ p = uint32(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint32(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint32(1) { - l-- + l = l - 1 } - p += uint32(2) + p = p + uint32(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint32(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v11] = uint8('/') + v4 = l + l = l + 1 + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') } if l+(q-p)+uint32(1) >= uint32(PATH_MAX) { goto toolong @@ -116990,19 +116990,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1168) defer tls.Free(1168) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+68 */ [1024]uint8 var _ /* hlen at bp+1092 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -117020,12 +117020,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint32FromInt32(l2) >= uint32(1024)-Uint32FromInt32(l) { l = Int32FromUint32(Uint32FromInt64(1024) - Uint32FromInt32(1)) } else { - l += l2 + l = l + l2 } if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 68)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]uint8)(unsafe.Pointer(bp + 68)))[v2] = uint8('\n') + v1 = l + l = l + 1 + (*(*[1024]uint8)(unsafe.Pointer(bp + 68)))[v1] = uint8('\n') } if Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+68, Uint32FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+564, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -117278,7 +117278,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -117523,11 +117523,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -117566,9 +117566,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -117577,10 +117577,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -117742,12 +117742,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + wn = wn - 1 goto _4 _4: } @@ -117762,44 +117762,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint32(4) + s = s + uintptr(4) + wn = wn - uint32(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117819,76 +117819,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint32(s)%uint32(4) == uint32(0) { for wn >= uint32(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = uint32(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = uint32(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = uint32(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = uint32(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint32(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint32(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = uint32(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint32(1) } @@ -118037,31 +118037,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if wc < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xc0) | wc>>Int32FromInt32(6)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(2) } else { if wc < uint32(0xd800) || wc-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(3) } else { if wc-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint32(4) } @@ -118107,16 +118107,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } _memcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -118132,9 +118132,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]uint8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint32(0) @@ -118148,9 +118148,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -118170,13 +118170,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint32FromInt32(1) != 0) { return Uint32FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118195,13 +118195,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -119312,9 +119312,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int32(s) - int32(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -119325,8 +119325,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -119338,20 +119338,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -119364,34 +119364,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint32FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -119405,17 +119405,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint32(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint32(253) || space <= 0 { return -int32(1) @@ -119466,22 +119466,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -119503,9 +119503,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -119541,26 +119541,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*uint8)(unsafe.Pointer(v3)) = uint8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if j >= int32(end)-int32(p) || j >= int32(dend)-int32(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) } } else { *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -119573,7 +119573,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -119608,7 +119608,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int32(end)-int32(p) < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119718,9 +119718,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119732,31 +119732,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int32(p)-int32(r) < rlen && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if len1+int32(10) > int32(r+uintptr(rlen))-int32(p) { return -int32(1) @@ -119764,7 +119764,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -120106,7 +120106,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -120118,7 +120118,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -120158,11 +120158,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 891 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -120205,9 +120205,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint32(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -120216,15 +120216,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint32(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 68 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*68 ___lock(tls, b+60) - p2 = b + 66 - *(*int16)(unsafe.Pointer(p2)) = int16(uint32(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 66 + *(*int16)(unsafe.Pointer(v2)) = int16(uint32(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+60) @@ -120241,7 +120241,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -120253,16 +120253,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -120365,7 +120365,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -120435,13 +120435,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -120572,7 +120572,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint32(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint32(1) + size = size + (size + uint32(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120637,15 +120637,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint32FromInt32(5)*Uint32FromInt64(4)-Uint32FromInt32(i)+l { return int32(ERANGE) } - buf += uintptr(uint32(4) - Uint32FromInt32(i)) - buflen -= Uint32FromInt32(5)*Uint32FromInt64(4) - Uint32FromInt32(i) + l + buf = buf + uintptr(uint32(4)-Uint32FromInt32(i)) + buflen = buflen - (Uint32FromInt32(5)*Uint32FromInt64(4) - Uint32FromInt32(i) + l) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint32FromInt32(2) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint32FromInt32(2) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(2)*Uint32FromInt64(4)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf _memcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, l) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*4)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) @@ -120695,7 +120695,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint32(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint32(1) + size = size + (size + uint32(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120754,41 +120754,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint32(buf) & (Uint32FromInt64(4) - Uint32FromInt32(1)) need = Uint32FromInt32(4) * Uint32FromInt64(4) - need += Uint32FromInt32(cnt+Int32FromInt32(1)) * (uint32(4) + Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint32(1) - need += Xstrlen(tls, bp+1344) + uint32(1) - need += align + need = need + Uint32FromInt32(cnt+Int32FromInt32(1))*(uint32(4)+Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint32(1)) + need = need + (Xstrlen(tls, bp+1344) + uint32(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint32FromInt32(3) * Uint32FromInt64(4)) + buf = buf + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint32FromInt32(cnt+Int32FromInt32(1)) * uint32(4)) + buf = buf + uintptr(Uint32FromInt32(cnt+Int32FromInt32(1))*uint32(4)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) _memcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)), bp+uintptr(i)*28+8, Uint32FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*4)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint32(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint32(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4))) + uint32(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)))+uint32(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*4)) = uintptr(0) } @@ -121049,7 +121049,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint32FromInt32(i)) if Uint32FromInt32(i) < uint32(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint32(16), 0) @@ -121230,17 +121230,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint32FromInt32(3) * Uint32FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -121253,29 +121253,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8('.') - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+922) } @@ -121285,15 +121285,15 @@ var _xdigits = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1744) defer tls.Free(1744) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+931, bp+1592, bp+512, uint32(1032)) if !(f != 0) { return @@ -121308,7 +121308,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -121326,14 +121326,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -121346,35 +121346,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*uint8)(unsafe.Pointer(p)) != 0; v13 { - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*uint8)(unsafe.Pointer(z)) != 0; v18 { - v15 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if int32(z)-int32(p) < int32(256) { @@ -121388,7 +121388,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1312) defer tls.Free(1312) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint32 var v4, v5 int32 var v7 bool @@ -121396,7 +121396,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]uint8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+955, bp+1168, bp+132, uint32(1032)) if !(f != 0) { return @@ -121406,7 +121406,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -121424,14 +121424,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint32FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -121531,7 +121531,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8('%') Xstrcat(tls, bp+78, p) @@ -121635,7 +121635,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint32FromInt32(2)*Uint32FromInt64(4)+Uint32FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121713,11 +121713,11 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, r1, v1, v10, v17, v19, v26, v8 int32 + var r, r1, v1, v8 int32 var tv uintptr - var v11, v12, v13, v14, v15, v16, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7 Tsyscall_arg_t + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t var _ /* tv32 at bp+8 */ [2]int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) v2 = fd @@ -121761,27 +121761,27 @@ _9: *(*[1]Tsocklen_t)(unsafe.Pointer(bp)) = [1]Tsocklen_t{ 0: uint32(8), } - v10 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v11 = fd - v12 = level - v13 = optname - v14 = int32(bp + 8) - v15 = int32(bp) - v16 = int32(Int32FromInt32(0)) + v2 = fd + v3 = level + v4 = optname + v5 = int32(bp + 8) + v6 = int32(bp) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, v10, v11, v12, v13, v14, v15, v16) + r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, v10, v11, v12, v13, v14, v15, v16) + r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } if r != int32(-Int32FromInt32(ENOSYS)) { - v17 = r + v8 = r goto _18 } - v17 = r + v8 = r goto _18 _18: - r1 = v17 + r1 = v8 if r1 < 0 { break } @@ -121801,27 +121801,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v19 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v20 = fd - v21 = level - v22 = optname - v23 = int32(optval) - v24 = int32(optlen) - v25 = int32(Int32FromInt32(0)) + v2 = fd + v3 = level + v4 = optname + v5 = int32(optval) + v6 = int32(optlen) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, v19, v20, v21, v22, v23, v24, v25) + r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, v19, v20, v21, v22, v23, v24, v25) + r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } if r != int32(-Int32FromInt32(ENOSYS)) { - v26 = r + v8 = r goto _27 } - v26 = r + v8 = r goto _27 _27: - r1 = v26 + r1 = v8 break } } @@ -121871,7 +121871,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -121883,16 +121883,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -122063,7 +122063,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) _memcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint32FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 16 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -122109,14 +122109,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p _memcpy(tls, p, s+9, uint32((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 8 } @@ -122138,9 +122138,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(48) defer tls.Free(48) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -122150,11 +122150,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+40, bp)) X__syscall1(tls, int32(SYS_close), fd) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -122202,7 +122202,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -122232,7 +122232,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -122259,12 +122259,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Uint8FromUint8(':') @@ -122391,7 +122391,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -122405,11 +122405,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -122430,7 +122430,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -122442,11 +122442,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -122456,7 +122456,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { @@ -122467,9 +122467,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*uint8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -122477,22 +122477,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -122509,15 +122509,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint32FromInt32(int32(2)*(i+int32(1)-brk))) @@ -122530,7 +122530,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -122538,16 +122538,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -122625,7 +122625,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i _memcpy(tls, buf+8, bp+4, uint32(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+84, int32(10)) @@ -122675,14 +122675,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122690,23 +122690,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122715,9 +122715,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122735,14 +122735,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1696) defer tls.Free(1696) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122765,15 +122765,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122792,7 +122792,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122800,26 +122800,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*uint8)(unsafe.Pointer(p)) != 0; v17 { - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*uint8)(unsafe.Pointer(v18)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122831,35 +122831,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*uint8)(unsafe.Pointer(p)) != 0; v23 { - v20 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*uint8)(unsafe.Pointer(z)) != 0; v28 { - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { @@ -122869,11 +122869,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122920,7 +122920,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 8 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 _memcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint32FromInt32(len1)) return 0 } @@ -122965,14 +122965,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10176, bp+10168, bp+10184, int32(4800), conf) < 0 { return -int32(11) @@ -122994,7 +122994,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -123009,7 +123009,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10192))).Fcnt @@ -123034,13 +123034,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]uint8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint32(256)) < 0 { return -int32(1) } @@ -123054,19 +123054,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= (*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { *(*uint8)(unsafe.Pointer(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint32(1))))) == int32('.') { return -int32(2) @@ -123097,23 +123097,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -123199,7 +123199,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -123235,7 +123235,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -123255,7 +123255,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -123265,7 +123265,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*uint8)(unsafe.Pointer(canon)) = uint8(0) if name != 0 { @@ -123283,7 +123283,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -123317,7 +123317,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -123326,18 +123326,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -123355,7 +123355,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -123374,7 +123374,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -123428,31 +123428,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { _memcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint32(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -123599,19 +123599,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*uint8)(unsafe.Pointer(p)) != 0; v19 { - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint32(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -123623,9 +123623,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+974, uint32(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -123633,18 +123633,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123807,34 +123807,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123849,21 +123849,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123876,14 +123876,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 20 + uintptr(i)*4)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123910,7 +123910,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123921,18 +123921,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32(eom)-int32(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ) > int32(eom)-int32(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if r > int32(eom)-int32(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(p) - int32(ptr) @@ -123949,8 +123949,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123985,22 +123985,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 44 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 44 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 44 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4)) - p4 = handle + 44 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4)) + v1 = handle + 44 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int32FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int32((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int32((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -124011,7 +124011,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 12 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -124134,7 +124134,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint32(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint32FromInt32(2))) + _idx = Int32FromUint32(uint32(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint32FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -124216,13 +124216,13 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti } bp := tls.Alloc(32) defer tls.Free(32) - var csize, v3, v6 uintptr + var csize, v3 uintptr var i, i1, ns, r, v2 int32 var s Ttime_t var v1 int64 var v4 t__predefined_size_t var v7 uint64 - _, _, _, _, _, _, _, _, _, _, _, _ = csize, i, i1, ns, r, s, v1, v2, v3, v4, v6, v7 + _, _, _, _, _, _, _, _, _, _, _ = csize, i, i1, ns, r, s, v1, v2, v3, v4, v7 defer func() { Xrealloc(tls, csize, 0) }() if timeout != 0 { v1 = (*Ttimespec)(unsafe.Pointer(timeout)).Ftv_sec @@ -124263,7 +124263,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _5 _5: ; - i++ + i = i + 1 } if timeout != 0 { if !((Uint64FromInt64(s)+Uint64FromUint64(0x80000000))>>Int32FromInt32(32) != 0) { @@ -124275,11 +124275,11 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti 0: int32(Int32FromUint64(v7)), 1: ns, } - v6 = bp + 16 + v3 = bp + 16 } else { - v6 = uintptr(0) + v3 = uintptr(0) } - r = int32(___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v6), 0)) + r = int32(___syscall_cp(tls, int32(SYS_recvmmsg), fd, int32(msgvec), Int32FromUint32(vlen), Int32FromUint32(flags), int32(v3), 0)) i1 = 0 for { if !(i1 < r) { @@ -124289,7 +124289,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _8 _8: ; - i1++ + i1 = i1 + 1 } return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -124300,11 +124300,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int32 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v7 + _, _, _, _ = cmsg, last, type1, v2 if false { return } @@ -124356,11 +124356,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v2 = cmsg + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -124371,11 +124371,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } *(*Tsocklen_t)(unsafe.Pointer(msg + 20)) += (Uint32FromInt64(16)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) if (*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len < uint32(12) || uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))+uint32(12) >= Uint32FromInt32(int32((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int32(last)) { - v7 = uintptr(0) + v2 = uintptr(0) } else { - v7 = last + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) + v2 = last + uintptr(uint32((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len+Uint32FromInt64(4)-Uint32FromInt32(1))&Uint32FromInt32(^Int32FromUint32(Uint32FromInt64(4)-Uint32FromInt32(1)))) } - cmsg = v7 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = (Uint32FromInt64(12)+Uint32FromInt64(4)-Uint32FromInt32(1)) & ^(Uint32FromInt64(4)-Uint32FromInt32(1)) + Uint32FromInt64(16) @@ -124442,7 +124442,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint32(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint32(1))))) == int32('.') { return -int32(1) @@ -124470,7 +124470,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -124613,7 +124613,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -124681,9 +124681,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 8 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -124703,7 +124703,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(272) defer tls.Free(272) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint32 @@ -124724,7 +124724,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124794,7 +124794,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124808,7 +124808,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 160)), uintptr(0)) @@ -124842,7 +124842,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124869,7 +124869,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124897,7 +124897,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124919,13 +124919,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124964,7 +124964,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124978,7 +124978,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124995,10 +124995,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*4)), Uint32FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+76+uintptr(j)*28, sl) } fallthrough @@ -125016,7 +125016,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { _memcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*4)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*4)), Uint32FromInt32(rlen)) @@ -125075,7 +125075,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -125127,7 +125127,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -125150,7 +125150,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -125180,9 +125180,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 4)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 8)) = _answer *(*int32)(unsafe.Pointer(bp + 12)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+16 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 12)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 4)), bp+16, int32(512)) if r >= 0 { @@ -125197,11 +125197,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+4, bp+8, bp+12, *(*int32)(unsafe.Pointer(bp + 12))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 12)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 12)) + v1 = *(*int32)(unsafe.Pointer(bp + 12)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -125231,16 +125231,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(672) defer tls.Free(672) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint32 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint32 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]uint8 var _ /* z at bp+656 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -125277,7 +125277,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1089) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+656, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { if x > uint32(15) { @@ -125290,103 +125290,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1096) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+656, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { if x1 > uint32(10) { - v6 = uint32(10) + v5 = uint32(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = v6 + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = v5 } } p = Xstrstr(tls, bp, __ccgo_ts+1106) if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+656, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 656)) != p { if x2 > uint32(60) { - v7 = uint32(60) + v5 = uint32(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = v7 + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = v5 } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v11 { - v8 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1115, uint32(10)) != 0); v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 656)) = p for { - if v20 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656)))) != 0; v20 { - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656)))) != 0; v4 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 656))++ + *(*uintptr)(unsafe.Pointer(bp + 656)) = *(*uintptr)(unsafe.Pointer(bp + 656)) + 1 } *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 656)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v24 { - v21 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1126, uint32(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1133, uint32(6)) != 0; !v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -125512,13 +125512,13 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, r1, v1, v11, v18, v20, v27, v8 int32 + var r, r1, v1, v8 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v10 uint64 - var v12, v13, v14, v15, v16, v17, v2, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8 + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) v2 = fd @@ -125574,27 +125574,27 @@ _9: 0: int32(s), 1: int32(Int32FromUint64(v10)), } - v11 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v12 = fd - v13 = level - v14 = optname - v15 = int32(bp) - v16 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) - v17 = int32(Int32FromInt32(0)) + v2 = fd + v3 = level + v4 = optname + v5 = int32(bp) + v6 = Int32FromUint32(Uint32FromInt32(2) * Uint32FromInt64(4)) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, v11, v12, v13, v14, v15, v16, v17) + r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, v11, v12, v13, v14, v15, v16, v17) + r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } if r != int32(-Int32FromInt32(ENOSYS)) { - v18 = r + v8 = r goto _19 } - v18 = r + v8 = r goto _19 _19: - r1 = v18 + r1 = v8 case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -125607,27 +125607,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v20 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v21 = fd - v22 = level - v23 = optname - v24 = int32(optval) - v25 = Int32FromUint32(optlen) - v26 = int32(Int32FromInt32(0)) + v2 = fd + v3 = level + v4 = optname + v5 = int32(optval) + v6 = Int32FromUint32(optlen) + v7 = int32(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, v20, v21, v22, v23, v24, v25, v26) + r = ___syscall_cp(tls, v1, v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, v20, v21, v22, v23, v24, v25, v26) + r = X__syscall6(tls, v1, v2, v3, v4, v5, v6, v7) } if r != int32(-Int32FromInt32(ENOSYS)) { - v27 = r + v8 = r goto _28 } - v27 = r + v8 = r goto _28 _28: - r1 = v27 + r1 = v8 break } } @@ -125904,18 +125904,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125930,14 +125930,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]uint8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125959,11 +125959,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint32(0) grlist_len = uint32(0) @@ -126003,11 +126003,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint32(4), uint32(1), f) < uint32(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -126021,12 +126021,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += *(*Tuint32_t)(unsafe.Pointer(bp + 44)) - grlist_len += *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + len1 = len1 + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) + grlist_len = grlist_len + *(*Tuint32_t)(unsafe.Pointer(bp + 44)) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -126039,11 +126039,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint32FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -126068,14 +126068,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*4)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*4)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -126137,9 +126137,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint32(16) - uint32(buf)) % uint32(16)) + buf = buf + uintptr((uint32(16)-uint32(buf))%uint32(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12)) + uint32(1)) * uint32(4)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 12))+uint32(1))*uint32(4)) _memcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 4))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int32((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int32(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -126152,7 +126152,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*4)) = uintptr(0) } @@ -126269,7 +126269,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126281,13 +126281,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+4 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) for { @@ -126308,32 +126308,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126345,12 +126345,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint32(4), *(*Tsize_t)(unsafe.Pointer(nmem))+uint32(1)) @@ -126370,21 +126370,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*4)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*4)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -126407,10 +126407,10 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(64) defer tls.Free(64) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t - var nlim, ret, rv, v14, v6 int32 + var nlim, ret, rv, v6 int32 var v3, v4 Tuint32_t var _ /* buf at bp+36 */ uintptr var _ /* gr at bp+0 */ Tgroup @@ -126420,7 +126420,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+24 */ [3]Tint32_t var _ /* size at bp+48 */ Tsize_t var _ /* swap at bp+20 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v3, v4, v6, v9 ret = -int32(1) n = int32(1) *(*int32)(unsafe.Pointer(bp + 20)) = 0 @@ -126464,7 +126464,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -126492,7 +126492,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -126503,17 +126503,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*4)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= nlim { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -126528,26 +126528,26 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= nlim { - v13 = groups + n = n + 1 + v9 = n + if v9 <= nlim { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > nlim { - v14 = -int32(1) + v6 = -int32(1) } else { - v14 = n + v6 = n } - ret = v14 + ret = v6 *(*int32)(unsafe.Pointer(ngroups)) = n goto cleanup cleanup: @@ -126562,18 +126562,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126588,11 +126588,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]uint8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -126614,11 +126614,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint32(0) *(*[11]uint8)(unsafe.Pointer(bp + 44)) = [11]uint8{} @@ -126670,11 +126670,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint32(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126838,7 +126838,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126852,10 +126852,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+4 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) for { @@ -126876,57 +126876,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int32(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v10)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v14)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126994,10 +126994,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+28 */ Tmsghdr var _ /* req_buf at bp+16 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 16)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -127083,7 +127083,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -127098,15 +127098,15 @@ retry: if !(i < len1/uint32(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -127511,7 +127511,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -127581,9 +127581,9 @@ func Xrandom(tls *TLS) (r int32) { trc("tls=%v, (%v:)", tls, origin(2)) defer func() { trc("-> %v", r) }() } - var k, v2, v3 int32 + var k, v2 int32 var v1 Tuint32_t - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -127593,14 +127593,14 @@ func Xrandom(tls *TLS) (r int32) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127656,7 +127656,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127672,7 +127672,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*4)) = UintptrFromInt32(0) _ = ap @@ -127700,7 +127700,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127716,7 +127716,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127744,7 +127744,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint32FromInt32(argc+int32(1)) * 4 @@ -127760,7 +127760,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*4)) = UintptrFromInt32(0) _ = ap @@ -127790,11 +127790,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1276) seen_eacces = 0 @@ -127821,7 +127821,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint32FromInt32(int32(z)-int32(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } @@ -127841,9 +127841,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -128326,7 +128326,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint32(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -128334,12 +128334,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint32(1) if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -128348,12 +128348,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint32(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) == int32('=')) { z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint32(1))))) - k += uint32(2) + k = k + uint32(2) if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -128362,7 +128362,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint32(1) @@ -128415,22 +128415,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -128448,15 +128448,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int32(p-uintptr(1))-int32(p0) < int32(16) { _memcpy(tls, bp+8, p0, Uint32FromInt32(int32(p-uintptr(1))-int32(p0))) @@ -128474,7 +128474,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(k) || *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(kfold) { return BoolInt32(!(inv != 0)) @@ -128482,7 +128482,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -128490,13 +128490,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+4 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint32(0) if flags&int32(FNM_PERIOD) != 0 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { @@ -128510,26 +128510,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+4) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 4)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 4)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128539,8 +128539,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -128565,13 +128565,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint32(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128591,18 +128591,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v10)))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128610,7 +128610,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -128620,22 +128620,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint32FromInt32(int32(endstr)-int32(s)), bp+4) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128657,7 +128657,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint32FromInt32(int32(endpat)-int32(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128669,11 +128669,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128683,7 +128683,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) goto _14 _14: } @@ -128694,9 +128694,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 4))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint32FromInt32(int32(endstr)-int32(str)), bp+4) < 0) { break @@ -128704,7 +128704,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128732,7 +128732,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128744,7 +128744,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128776,7 +128776,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128831,13 +128831,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(160) defer tls.Free(160) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep uint8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128849,9 +128849,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint32(1) < uint32(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128868,8 +128868,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint32FromInt32(j) + pat = pat + uintptr(i) + pos = pos + Uint32FromInt32(j) v4 = Int32FromInt32(0) j = v4 i = v4 @@ -128889,7 +128889,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int32(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128898,9 +128898,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int32(1)) + pat = pat + uintptr(i+int32(1)) i = -int32(1) - pos += Uint32FromInt32(j + int32(1)) + pos = pos + Uint32FromInt32(j+int32(1)) j = -int32(1) } /* Only store a character if it fits in the buffer, but if @@ -128909,9 +128909,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint32FromInt32(j+Int32FromInt32(1)) < uint32(PATH_MAX) { - v5 = j - j++ - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v5)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint32FromInt32(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128925,7 +128925,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { @@ -128960,19 +128960,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int32(p2)-int32(p))%int32(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = uint8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 483 + v2 = __ccgo_ts + 483 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128982,9 +128982,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -129022,11 +129022,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*uint8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -129072,13 +129072,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(32) defer tls.Free(32) - var delim, v1, v12 uint8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 uint8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+28 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint32(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -129086,16 +129086,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*uint8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1310) + v2 = Xgetenv(tls, __ccgo_ts+1310) } - home = v3 + home = v2 if !(home != 0) { if *(*uint8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint32(PATH_MAX), bp+28) @@ -129130,20 +129130,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint32FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) } if *(*uint8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v13))) = uint8(0) + v1 = delim + *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -129217,7 +129217,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -129225,7 +129225,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+4, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -129239,7 +129239,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint32(1))*uint32(4)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -129255,7 +129255,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint32(0) @@ -129269,7 +129269,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 4)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*4)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -129294,7 +129294,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint32(0) @@ -129690,7 +129690,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*4)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129732,7 +129732,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*4)) } @@ -129742,7 +129742,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*4)) } @@ -129840,7 +129840,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129878,16 +129878,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 8 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*4 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint32(20)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129900,8 +129900,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129912,16 +129912,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129932,11 +129932,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129985,11 +129985,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]uint8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint32(0) @@ -130014,7 +130014,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('[') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*uint8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -130029,21 +130029,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - max = v4 - min = v4 - s += uintptr(len1) + v2 = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + max = v2 + min = v2 + s = s + uintptr(len1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint32FromInt32(-Int32FromInt32(1))) max = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) /* XXX - Should use collation order instead of @@ -130051,7 +130051,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -130059,9 +130059,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*4)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*4)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130094,11 +130094,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(288) defer tls.Free(288) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+16 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -130111,7 +130111,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 16))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 16))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+16) if err != REG_OK { @@ -130170,11 +130170,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -130193,13 +130193,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -130212,7 +130212,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -130239,12 +130239,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -130258,7 +130258,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -130281,7 +130281,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -130307,11 +130307,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('['): @@ -130353,7 +130353,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { case 0: @@ -130367,12 +130367,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -130387,20 +130387,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 24 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -130416,7 +130416,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -130425,47 +130425,47 @@ _2: if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 24 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 24 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 24 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 24 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 24 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -130474,7 +130474,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -130483,7 +130483,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -130527,8 +130527,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -130546,12 +130546,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -130560,7 +130560,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -130568,28 +130568,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -130628,7 +130628,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130652,7 +130652,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130673,24 +130673,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130831,7 +130831,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130891,7 +130891,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130932,7 +130932,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130945,7 +130945,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130963,7 +130963,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130976,7 +130976,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*12))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130995,7 +130995,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -131030,13 +131030,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -131044,8 +131044,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -131080,7 +131080,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -131150,20 +131150,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -131247,26 +131247,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -131280,7 +131280,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -131374,7 +131374,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -131396,13 +131396,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -131457,8 +131457,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == -int32(3) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131697,7 +131697,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131738,7 +131738,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131781,7 +131781,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131798,8 +131798,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131862,7 +131862,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131872,7 +131872,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131882,7 +131882,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint32(32)*Uint32FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131911,7 +131911,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint32FromInt64(4)*Uint32FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131926,7 +131926,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131937,7 +131937,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*32))).Ftags = new_tags @@ -131945,7 +131945,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131971,7 +131971,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint32(4)*Uint32FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131986,7 +131986,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Ftags = new_tags @@ -131994,7 +131994,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*32))).Fposition = -int32(1) return new_set @@ -132008,9 +132008,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -132039,7 +132039,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max @@ -132047,13 +132047,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case -int32(2): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = *(*int32)(unsafe.Pointer(p2)) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max } case -int32(1): default: @@ -132354,9 +132354,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -132410,7 +132410,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint32(4)*Uint32FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -132425,7 +132425,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*4)) = Uint32FromInt32(0) } else { @@ -132435,13 +132435,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -132459,7 +132459,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -132480,14 +132480,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -132502,7 +132502,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 32 } p1 += 32 @@ -132685,7 +132685,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 24 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132730,7 +132730,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132740,12 +132740,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, Uint32FromInt32(add)+uint32(1), uint32(32)) if transitions == UintptrFromInt32(0) { @@ -132767,7 +132767,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 32 } initial = Xcalloc(tls, Uint32FromInt32(i)+uint32(1), uint32(32)) @@ -132798,7 +132798,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags = Xmalloc(tls, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags != 0) { @@ -132810,7 +132810,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { _memcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint32(4)*Uint32FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*32))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132873,7 +132873,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132906,7 +132906,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132947,11 +132947,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint32(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint32(1)) } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint32FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132994,7 +132994,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -133046,13 +133046,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint32 + var v1 uint32 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) @@ -133105,44 +133105,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint32(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v2 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v2 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v3 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v3 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint32FromInt32(int32(tmp_buf))%uint32(4) != 0 { - v4 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) + v1 = uint32(4) - Uint32FromInt32(int32(tmp_buf))%uint32(4) } else { - v4 = uint32(0) + v1 = uint32(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*8))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*8))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -133153,10 +133153,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v7 if v7 <= 0 { @@ -133164,10 +133164,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -133190,7 +133190,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -133213,7 +133213,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*8))).Fpos = pos @@ -133234,18 +133234,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -133280,7 +133280,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -133329,7 +133329,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -133360,7 +133360,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 8 @@ -133384,7 +133384,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -133465,13 +133465,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) @@ -133535,7 +133535,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -133546,12 +133546,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) pos_add_next = v3 if v3 <= 0 { @@ -133559,10 +133559,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) str_byte_start = str_byte @@ -133632,7 +133632,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133682,7 +133682,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133713,21 +133713,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int32(1)) - pos += bt_len - int32(1) + str_byte = str_byte + uintptr(bt_len-int32(1)) + pos = pos + (bt_len - int32(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133738,18 +133738,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = Xmbtowc(tls, bp, str_byte, uint32(MB_LEN_MAX)) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133820,7 +133820,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133848,9 +133848,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*4)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*4)) = pos } } goto _17 @@ -133877,7 +133877,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133933,8 +133933,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133957,7 +133957,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133973,23 +133973,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*8))).Frm_eo { - v3 = -Int32FromInt32(1) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v3 + v1 = -Int32FromInt32(1) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for i < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_so = -int32(1) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*8))).Frm_eo = -int32(1) - i++ + i = i + 1 } } @@ -134215,7 +134215,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint32(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint32(31)*h + uint32(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -134238,7 +134238,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint32(2) + newsize = newsize * uint32(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint32(8)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -134266,8 +134266,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -134310,8 +134310,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -134367,11 +134367,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 8 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint32(4) { if !(_resize(tls, uint32(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -134450,7 +134450,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint32(1) return _memcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -134482,7 +134482,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -134503,9 +134503,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [49]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -134514,11 +134514,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -134527,9 +134527,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 4 + BoolUintptr(c > 0)*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + BoolUintptr(c > 0)*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) goto _3 _3: @@ -134538,14 +134538,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 4)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 4 + v1 = i + i = i + 1 + a[v1] = n + 4 n = *(*uintptr)(unsafe.Pointer(n + 4)) for *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) != 0 { - v6 = i - i++ - a[v6] = n + 4 + 1*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + 1*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + 1*4)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -134555,13 +134555,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134702,17 +134702,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [48]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134722,9 +134722,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 4 + BoolUintptr(c > 0)*4 + v1 = i + i = i + 1 + a[v1] = n + 4 + BoolUintptr(c > 0)*4 n = *(*uintptr)(unsafe.Pointer(n + 4 + BoolUintptr(c > 0)*4)) goto _2 _2: @@ -134739,15 +134739,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 4)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134796,9 +134796,9 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 if to != 0 { v1 = (*Ttimespec)(unsafe.Pointer(to)).Ftv_sec } else { @@ -134838,11 +134838,11 @@ func Xppoll(tls *TLS, fds uintptr, n Tnfds_t, to uintptr, mask uintptr) (r1 int3 0: int32(s), 1: ns, } - v5 = bp + 16 + v3 = bp + 16 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v5), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_ppoll), int32(fds), Int32FromUint32(n), int32(v3), int32(mask), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0))) } func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts uintptr, mask uintptr) (r1 int32) { @@ -134855,10 +134855,10 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 var _ /* data at bp+24 */ [2]Tsyscall_arg_t - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4 *(*[2]Tsyscall_arg_t)(unsafe.Pointer(bp + 24)) = [2]Tsyscall_arg_t{ 0: Int32FromUint32(uint32(mask)), 1: int32(Int32FromInt32(_NSIG) / Int32FromInt32(8)), @@ -134902,11 +134902,11 @@ func Xpselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, ts ui 0: int32(s), 1: ns, } - v5 = bp + 16 + v3 = bp + 16 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pselect6), n, int32(rfds), int32(wfds), int32(efds), int32(v5), int32(bp+24)))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS_pselect6), n, int32(rfds), int32(wfds), int32(efds), int32(v3), int32(bp+24)))) } func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uintptr) (r1 int32) { @@ -134920,9 +134920,9 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin var ns, r int32 var us Tsuseconds_t var v1, v2 int64 - var v3, v5 uintptr + var v3 uintptr var v4 uint64 - _, _, _, _, _, _, _, _, _, _ = max_time, ns, r, s, us, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = max_time, ns, r, s, us, v1, v2, v3, v4 if tv != 0 { v1 = (*Ttimeval)(unsafe.Pointer(tv)).Ftv_sec } else { @@ -134944,8 +134944,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int32(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = int32(us * int64(1000)) } r = -int32(ENOSYS) @@ -134978,11 +134978,11 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin 0: int32(s), 1: int32(us), } - v5 = bp + 24 + v3 = bp + 24 } else { - v5 = uintptr(0) + v3 = uintptr(0) } - return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS__newselect), n, int32(rfds), int32(wfds), int32(efds), int32(v5), 0))) + return X__syscall_ret(tls, Uint32FromInt32(___syscall_cp(tls, int32(SYS__newselect), n, int32(rfds), int32(wfds), int32(efds), int32(v3), 0))) } var _all_mask = [2]uint32{ @@ -135202,7 +135202,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) bp := tls.Alloc(64) defer tls.Free(64) var old, r, v2 int32 - var v1, v10, v11, v12, v3, v5, v6, v8 uintptr + var v1, v3, v5, v6, v8 uintptr var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+36 */ Tk_sigaction var _ /* u at bp+8 */ struct { @@ -135210,7 +135210,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _ = old, r, v1, v10, v11, v12, v2, v3, v5, v6, v8 + _, _, _, _, _, _, _, _ = old, r, v1, v2, v3, v5, v6, v8 if sa != 0 { if uint32(*(*uintptr)(unsafe.Pointer(sa))) > uint32(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint32FromInt32(sig-Int32FromInt32(1))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 @@ -135285,24 +135285,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint32(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { - v10 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v10 = __ccgo_fp(X__restore) + v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v10 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 _memcpy(tls, bp+16+12, sa+4, Uint32FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v11 = bp + 16 + v1 = bp + 16 } else { - v11 = uintptr(0) + v1 = uintptr(0) } if old1 != 0 { - v12 = bp + 36 + v3 = bp + 36 } else { - v12 = uintptr(0) + v3 = uintptr(0) } - r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v11), int32(v12), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r = int32(X__syscall4(tls, int32(SYS_rt_sigaction), sig, int32(v1), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint32((*(*Tk_sigaction)(unsafe.Pointer(bp + 36))).Fflags) @@ -135404,7 +135404,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135482,7 +135482,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -135521,7 +135521,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135638,9 +135638,9 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) var ns, r, v2 int32 var s Ttime_t var v1 int64 - var v3, v4 uintptr + var v3 uintptr var v5 uint64 - _, _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = ns, r, s, v1, v2, v3, v5 if ts != 0 { v1 = (*Ttimespec)(unsafe.Pointer(ts)).Ftv_sec } else { @@ -135679,11 +135679,11 @@ func _do_sigtimedwait(tls *TLS, mask uintptr, si uintptr, ts uintptr) (r1 int32) 0: int32(Int32FromUint64(v5)), 1: ns, } - v4 = bp + 16 + v3 = bp + 16 } else { - v4 = uintptr(0) + v3 = uintptr(0) } - return int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v4), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) + return int32(___syscall_cp(tls, int32(SYS_rt_sigtimedwait), int32(mask), int32(si), int32(v3), int32(Int32FromInt32(_NSIG)/Int32FromInt32(8)), 0, 0)) return r1 } @@ -135883,7 +135883,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int32(SYS_statx), fd, int32(path), flag, int32(Int32FromInt32(0x7ff)), int32(bp))) if ret != 0 { return ret @@ -136097,7 +136097,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -136272,9 +136272,9 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r defer tls.Free(64) var i, ns0, ns1, r int32 var s0, s1 Ttime_t - var tv, v1, v2 uintptr + var tv, v1 uintptr var _ /* tmp at bp+48 */ [4]int32 - _, _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1, v2 + _, _, _, _, _, _, _, _ = i, ns0, ns1, r, s0, s1, tv, v1 if times != 0 && (*(*Ttimespec)(unsafe.Pointer(times))).Ftv_nsec == int32(UTIME_NOW) && (*(*Ttimespec)(unsafe.Pointer(times + 1*16))).Ftv_nsec == int32(UTIME_NOW) { times = uintptr(0) } @@ -136320,11 +136320,11 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r 2: int32(s1), 3: ns1, } - v2 = bp + 32 + v1 = bp + 32 } else { - v2 = uintptr(0) + v1 = uintptr(0) } - r = int32(X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v2), flags)) + r = int32(X__syscall4(tls, int32(SYS_utimensat), fd, int32(path), int32(v1), flags)) if r != -int32(ENOSYS) || flags != 0 { return X__syscall_ret(tls, Uint32FromInt32(r)) } @@ -136347,7 +136347,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r goto _3 _3: ; - i++ + i = i + 1 } } r = int32(X__syscall3(tls, int32(SYS_futimesat), fd, int32(path), int32(tv))) @@ -136456,19 +136456,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -136513,7 +136513,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 20 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -136589,10 +136589,10 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var cnt Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4 uintptr var _ /* iov at bp+0 */ [2]Tiovec - _, _, _, _, _ = cnt, v1, v2, v3, v4 + _, _, _, _ = cnt, v1, v3, v4 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: buf, @@ -136611,23 +136611,23 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { cnt = v1 if cnt <= 0 { if cnt != 0 { - v2 = int32(F_ERR) + v1 = int32(F_ERR) } else { - v2 = int32(F_EOF) + v1 = int32(F_EOF) } - *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v2) + *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v1) return uint32(0) } if Uint32FromInt32(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint32FromInt32(cnt) } - cnt = Tssize_t(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint32(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -136649,12 +136649,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(16) defer tls.Free(16) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint32 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -136678,11 +136678,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint32(0) @@ -136691,11 +136691,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint32FromInt32(cnt) + rem = rem - Uint32FromInt32(cnt) if Uint32FromInt32(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int32FromUint32(uint32(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 8 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint32FromInt32(cnt) @@ -136725,9 +136725,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) @@ -136741,9 +136741,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -136764,8 +136764,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 72)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -136776,9 +136776,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136947,8 +136947,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136957,9 +136957,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -137030,7 +137030,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -137143,16 +137143,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -137166,7 +137166,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137180,11 +137180,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+76) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint32(0)) @@ -137205,9 +137205,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -137223,9 +137223,9 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r int32) { - var c, old, old1, v11, v12, v2, v4, v8 int32 - var v1, v10, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + var c, old, old1, v11, v2, v4, v8 int32 + var v1, v5, v6, v7 uintptr + _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v11, v2, v4, v5, v6, v7, v8 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -137239,34 +137239,34 @@ _3: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v6 = f + 4 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v5 = f + 4 + v1 = *(*uintptr)(unsafe.Pointer(v5)) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v4 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v4 - v7 = f + 76 + c = v2 + v6 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v7, 0) != 0) { - old1 = _a_ll(tls, v7) + for cond := true; cond; cond = !(_a_sc(tls, v6, 0) != 0) { + old1 = _a_ll(tls, v6) } _a_barrier(tls) - v8 = old1 + v4 = old1 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { - v10 = f + 76 + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 76 + v8 = int32(1) v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)|v11), v8) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)), v8) != 0 } return c } @@ -137285,7 +137285,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -137308,9 +137308,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -137321,21 +137321,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v7) - int32(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint32FromInt32(int32(v3) - int32(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -137372,12 +137372,12 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v2, v4, v5 int32 + var __need_unlock, c, v1, v2 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v3 uint32 var v8 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v6, v7, v8 p = s if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -137396,16 +137396,16 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*uint8)(unsafe.Pointer(s)) = uint8(0) return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) if z != 0 { - v2 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) + v1 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) } else { - v2 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + v1 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) } - k = Uint32FromInt32(v2) + k = Uint32FromInt32(v1) if k < Uint32FromInt32(n) { v3 = k } else { @@ -137414,8 +137414,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 _memcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - p += uintptr(k) - n = int32(uint32(n) - k) + p = p + uintptr(k) + n = Int32FromUint32(uint32(n) - k) if z != 0 || !(n != 0) { break } @@ -137423,24 +137423,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v2 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = Uint8FromInt32(c) - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } @@ -137487,7 +137487,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -137577,22 +137577,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+76) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -137610,7 +137610,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = uint32(0) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -137620,11 +137620,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -137740,7 +137740,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } _memcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137905,11 +137905,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = -int32(1) remain = len1 @@ -137923,8 +137923,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint32FromInt32(ret) - remain -= Uint32FromInt32(ret) + readlen = readlen + Uint32FromInt32(ret) + remain = remain - Uint32FromInt32(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint32(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137936,10 +137936,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137951,9 +137951,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -138081,10 +138081,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, v12, v13, v2, v4, v9 int32 - var v1, v11, v6, v7, v8 uintptr + var old, old1, v2, v4, v9 int32 + var v1, v6 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = old, old1, v1, v2, v4, v5, v6, v9 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -138099,35 +138099,35 @@ _3: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v5 = Uint8FromInt32(c) - v7 = f + 20 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v6 = f + 20 + v1 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v5 + v2 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 76 + c = v2 + v1 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v8, 0) != 0) { - old1 = _a_ll(tls, v8) + for cond := true; cond; cond = !(_a_sc(tls, v1, 0) != 0) { + old1 = _a_ll(tls, v1) } _a_barrier(tls) - v9 = old1 + v2 = old1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 76 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 76 + v4 = int32(1) + v9 = int32(1) + if v9 != 0 { + v9 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)|v9), v4) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)), v4) != 0 } return c } @@ -138149,7 +138149,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -138207,7 +138207,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = uint8(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -138337,8 +138337,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint32 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint32 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -138362,8 +138362,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 _memcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -138371,11 +138371,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint32(0) + v2 = uint32(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138385,8 +138385,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138430,7 +138430,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFD)), int32(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint32FromInt32(X__syscall3(tls, int32(SYS_fcntl64), (*TFILE)(unsafe.Pointer(f)).Ffd, int32(Int32FromInt32(F_SETFL)), fl))) < 0 { goto fail } @@ -138497,8 +138497,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -138506,7 +138506,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64(int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos)) + off = off - int64(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -138526,9 +138526,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138605,10 +138605,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos) - int32((*TFILE)(unsafe.Pointer(f)).Frend)) + pos = pos + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64(int32((*TFILE)(unsafe.Pointer(f)).Fwpos) - int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) + pos = pos + int64(int32((*TFILE)(unsafe.Pointer(f)).Fwpos)-int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -138713,11 +138713,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var old, owner, tid, v1, v3 int32 + var old, owner, tid, v1 int32 var self Tpthread_t var v2 uintptr var v5 bool - _, _, _, _, _, _, _, _ = old, owner, self, tid, v1, v2, v3, v5 + _, _, _, _, _, _, _ = old, owner, self, tid, v1, v2, v5 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 76) @@ -138725,7 +138725,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int32(0x7fffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -138740,11 +138740,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { old = _a_ll(tls, v2) } _a_barrier(tls) - v3 = old + v1 = old goto _4 _4: } - if v5 || v3 != 0 { + if v5 || v1 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -138760,7 +138760,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -138769,9 +138769,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138794,11 +138794,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138846,15 +138846,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } _memcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138924,9 +138924,9 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r int32) { - var c, old, old1, v11, v12, v2, v4, v8 int32 - var v1, v10, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + var c, old, old1, v11, v2, v4, v8 int32 + var v1, v5, v6, v7 uintptr + _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v11, v2, v4, v5, v6, v7, v8 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -138940,34 +138940,34 @@ _3: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v6 = f + 4 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v5 = f + 4 + v1 = *(*uintptr)(unsafe.Pointer(v5)) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v4 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v4 - v7 = f + 76 + c = v2 + v6 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v7, 0) != 0) { - old1 = _a_ll(tls, v7) + for cond := true; cond; cond = !(_a_sc(tls, v6, 0) != 0) { + old1 = _a_ll(tls, v6) } _a_barrier(tls) - v8 = old1 + v4 = old1 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { - v10 = f + 76 + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 76 + v8 = int32(1) v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)|v11), v8) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)), v8) != 0 } return c } @@ -138986,7 +138986,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139019,7 +139019,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -139044,9 +139044,9 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r int32) { - var c, old, old1, v11, v12, v2, v4, v8 int32 - var v1, v10, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v11, v12, v2, v4, v5, v6, v7, v8 + var c, old, old1, v11, v2, v4, v8 int32 + var v1, v5, v6, v7 uintptr + _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v11, v2, v4, v5, v6, v7, v8 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -139060,34 +139060,34 @@ _3: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v6 = f + 4 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v5 = f + 4 + v1 = *(*uintptr)(unsafe.Pointer(v5)) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v4 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v4 - v7 = f + 76 + c = v2 + v6 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v7, 0) != 0) { - old1 = _a_ll(tls, v7) + for cond := true; cond; cond = !(_a_sc(tls, v6, 0) != 0) { + old1 = _a_ll(tls, v6) } _a_barrier(tls) - v8 = old1 + v4 = old1 goto _9 _9: - if v8&int32(MAYBE_WAITERS) != 0 { - v10 = f + 76 + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 76 + v8 = int32(1) v11 = int32(1) - v12 = int32(1) - if v12 != 0 { - v12 = int32(FUTEX_PRIVATE) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v11 < Int32FromInt32(0) { - v11 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)|v12), v11) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v10), int32(Int32FromInt32(FUTEX_WAKE)), v11) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)|v11), v8) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v7), int32(Int32FromInt32(FUTEX_WAKE)), v8) != 0 } return c } @@ -139106,7 +139106,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139131,7 +139131,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139144,11 +139144,11 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v3, v4, v5 int32 + var __need_unlock, c, v1, v3 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v6, v7 i = uint32(0) if AtomicLoadPInt32(f+76) >= 0 { v1 = ___lockfile(tls, f) @@ -139172,11 +139172,11 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, delim, Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Frend)-int32((*TFILE)(unsafe.Pointer(f)).Frpos))) if z != 0 { - v3 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) + v1 = int32(z) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + int32(1) } else { - v3 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) + v1 = int32((*TFILE)(unsafe.Pointer(f)).Frend) - int32((*TFILE)(unsafe.Pointer(f)).Frpos) } - k = Uint32FromInt32(v3) + k = Uint32FromInt32(v1) } else { z = uintptr(0) k = uint32(0) @@ -139184,7 +139184,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint32(2) if !(z != 0) && m < Uint32FromUint32(0xffffffff)/Uint32FromInt32(4) { - m += m / uint32(2) + m = m + m/uint32(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -139211,7 +139211,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { _memcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 4)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -139219,14 +139219,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 4 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v3 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v3 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -139238,14 +139238,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint32(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 4 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 4 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break @@ -139297,7 +139297,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 4 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139308,7 +139308,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) } *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) @@ -139488,17 +139488,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint32(1192)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint32(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint32(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139514,9 +139514,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*uint8)(unsafe.Pointer(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139634,17 +139634,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint32(184)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint32(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint32(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139660,9 +139660,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = uint32(0) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139753,10 +139753,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, v12, v13, v2, v4, v9 int32 - var v1, v11, v6, v7, v8 uintptr + var old, old1, v2, v4, v9 int32 + var v1, v6 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = old, old1, v1, v2, v4, v5, v6, v9 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -139771,35 +139771,35 @@ _3: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v5 = Uint8FromInt32(c) - v7 = f + 20 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v6 = f + 20 + v1 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v5 + v2 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 76 + c = v2 + v1 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v8, 0) != 0) { - old1 = _a_ll(tls, v8) + for cond := true; cond; cond = !(_a_sc(tls, v1, 0) != 0) { + old1 = _a_ll(tls, v1) } _a_barrier(tls) - v9 = old1 + v2 = old1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 76 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 76 + v4 = int32(1) + v9 = int32(1) + if v9 != 0 { + v9 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)|v9), v4) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)), v4) != 0 } return c } @@ -139821,7 +139821,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139857,7 +139857,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139883,10 +139883,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, v12, v13, v2, v4, v9 int32 - var v1, v11, v6, v7, v8 uintptr + var old, old1, v2, v4, v9 int32 + var v1, v6 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v12, v13, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = old, old1, v1, v2, v4, v5, v6, v9 v1 = f + 76 _a_barrier(tls) for cond := true; cond; cond = old == 0 && !(_a_sc(tls, v1, Int32FromInt32(MAYBE_WAITERS)-Int32FromInt32(1)) != 0) { @@ -139901,35 +139901,35 @@ _3: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v5 = Uint8FromInt32(c) - v7 = f + 20 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v6 = f + 20 + v1 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v5 + v2 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 76 + c = v2 + v1 = f + 76 _a_barrier(tls) - for cond := true; cond; cond = !(_a_sc(tls, v8, 0) != 0) { - old1 = _a_ll(tls, v8) + for cond := true; cond; cond = !(_a_sc(tls, v1, 0) != 0) { + old1 = _a_ll(tls, v1) } _a_barrier(tls) - v9 = old1 + v2 = old1 goto _10 _10: - if v9&int32(MAYBE_WAITERS) != 0 { - v11 = f + 76 - v12 = int32(1) - v13 = int32(1) - if v13 != 0 { - v13 = int32(FUTEX_PRIVATE) + if v2&int32(MAYBE_WAITERS) != 0 { + v6 = f + 76 + v4 = int32(1) + v9 = int32(1) + if v9 != 0 { + v9 = int32(FUTEX_PRIVATE) } - if v12 < Int32FromInt32(0) { - v12 = int32(INT_MAX) + if v4 < Int32FromInt32(0) { + v4 = int32(INT_MAX) } - _ = X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)|v13), v12) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v11), int32(Int32FromInt32(FUTEX_WAKE)), v12) != 0 + _ = X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)|v9), v4) != -int32(ENOSYS) || X__syscall3(tls, int32(SYS_futex), int32(v6), int32(Int32FromInt32(FUTEX_WAKE)), v4) != 0 } return c } @@ -139951,7 +139951,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 20 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139979,7 +139979,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -140009,7 +140009,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 20 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -140345,7 +140345,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140380,7 +140380,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140416,7 +140416,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140450,7 +140450,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 4 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -140467,12 +140467,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 88 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+76) >= 0 { @@ -140489,10 +140489,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint32(Xwcrtomb(tls, bp, c, uintptr(0))) - l = v2 + v1 = Int32FromUint32(Xwcrtomb(tls, bp, c, uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140501,13 +140501,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 4 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 4 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - _memcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint32FromInt32(l)) + v4 = f + 4 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + _memcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint32FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140784,7 +140784,7 @@ func _pad3(tls *TLS, f uintptr, c uint8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint32(l) - Uint32FromInt64(256)) + l = Int32FromUint32(uint32(l) - Uint32FromInt64(256)) } _out(tls, f, bp, Uint32FromInt32(l)) } @@ -140798,13 +140798,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140816,45 +140816,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint32 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > uint64(Uint32FromUint32(2)*Uint32FromInt32(0x7fffffff)+Uint32FromInt32(1))) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = uint32(x) for { if !(y != 0) { break } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint32('0') + y%uint32(10)) + s = s - 1 + v2 = s + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + y%uint32(10)) goto _3 _3: ; - y /= uint32(10) + y = y / uint32(10) } return s } @@ -140869,12 +140869,12 @@ type Tcompiler_defines_long_double_incorrectly = [1]uint8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v36, v37, v38, v39, v40, v41, v42, v45, v52, v57, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7, v8, v9 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 + var v1 uint64 var _ /* __u at bp+0 */ struct { F__ccgo_align [0]uint32 F__i [0]uint64 @@ -140884,7 +140884,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]uint8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v5, v6, v7, v8, v9 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1419 ebuf = bp + 538 + uintptr(Uint32FromInt32(3)*Uint32FromInt64(4)) @@ -140897,21 +140897,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*uint8)(unsafe.Pointer(v10)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v11)) = Uint8FromInt32(v12) - estr-- - v13 = estr - *(*uint8)(unsafe.Pointer(v13)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int32(s)-t__predefined_ptrdiff_t(bp+516) == int32(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*uint8)(unsafe.Pointer(v15)) = uint8('.') + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = uint8('.') } } if p > Int32FromInt32(INT_MAX)-Int32FromInt32(2)-(int32(ebuf)-int32(estr))-pl { @@ -141023,46 +141023,46 @@ _4: _out(tls, f, estr, Uint32FromInt32(int32(ebuf)-int32(estr))) _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint32FromInt64(504)/Uint32FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint32FromInt64(504)/Uint32FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -141078,22 +141078,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -141112,21 +141112,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int32(z)-int32(b))/4 > need { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -141138,8 +141138,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -141149,10 +141149,10 @@ _4: if j < int32(9)*((int32(z)-int32(r))/4-int32(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -141160,15 +141160,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -141180,23 +141180,23 @@ _4: } } if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = Int32FromInt32(9) * ((int32(r) - int32(a)) / 4) @@ -141207,8 +141207,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -141227,14 +141227,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -141248,46 +141248,46 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) } if t|int32(32) == int32('f') { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))-j { - v37 = 0 + v8 = 0 } else { - v37 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j + v8 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j } - if p < v37 { - v36 = p + if p < v8 { + v7 = p } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))-j { - v38 = 0 + v9 = 0 } else { - v38 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j + v9 = int32(9)*((int32(z)-int32(r))/4-int32(1)) - j } - v36 = v38 + v7 = v9 } - p = v36 + p = v7 } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))+e-j { - v40 = 0 + v8 = 0 } else { - v40 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j + v8 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j } - if p < v40 { - v39 = p + if p < v8 { + v7 = p } else { if 0 > int32(9)*((int32(z)-int32(r))/4-int32(1))+e-j { - v41 = 0 + v9 = 0 } else { - v41 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j + v9 = int32(9)*((int32(z)-int32(r))/4-int32(1)) + e - j } - v39 = v41 + v7 = v9 } - p = v39 + p = v7 } } } @@ -141300,35 +141300,35 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int32(ebuf)-int32(estr) < int32(2) { - estr-- - v43 = estr - *(*uint8)(unsafe.Pointer(v43)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v44)) = Uint8FromInt32(v45) - estr-- - v46 = estr - *(*uint8)(unsafe.Pointer(v46)) = Uint8FromInt32(t) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) if int32(ebuf)-int32(estr) > int32(INT_MAX)-l { return -int32(1) } - l += int32(ebuf) - int32(estr) + l = l + (int32(ebuf) - int32(estr)) } if l > int32(INT_MAX)-pl { return -int32(1) @@ -141348,15 +141348,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*uint8)(unsafe.Pointer(v48)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*uint8)(unsafe.Pointer(v49)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } _out(tls, f, s2, Uint32FromInt32(int32(bp+516+uintptr(9))-int32(s2))) @@ -141374,21 +141374,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*uint8)(unsafe.Pointer(v51)) = uint8('0') + s3 = s3 - 1 + v5 = s3 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint32FromInt32(v52)) + _out(tls, f, s3, Uint32FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, uint8('0'), p+int32(9), int32(9), 0) } else { @@ -141402,31 +141402,31 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*uint8)(unsafe.Pointer(v54)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*uint8)(unsafe.Pointer(v55)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint32(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint32(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+483, uint32(1)) } } if int32(bp+516+UintptrFromInt32(9))-int32(s4) < p { - v57 = int32(bp+516+UintptrFromInt32(9)) - int32(s4) + v7 = int32(bp+516+UintptrFromInt32(9)) - int32(s4) } else { - v57 = p + v7 = p } - _out(tls, f, s4, Uint32FromInt32(v57)) - p -= int32(bp+516+uintptr(9)) - int32(s4) + _out(tls, f, s4, Uint32FromInt32(v7)) + p = p - (int32(bp+516+uintptr(9)) - int32(s4)) goto _53 _53: ; @@ -141437,11 +141437,11 @@ _4: } _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -141460,7 +141460,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -141468,17 +141468,17 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v34, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st, v31 uint32 var i Tsize_t - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]uint8 var _ /* mb at bp+48 */ [4]uint8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -141491,7 +141491,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -141504,7 +141504,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -141514,8 +141514,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int32(z)-int32(a) > int32(INT_MAX)-cnt { goto overflow @@ -141530,10 +141530,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -141541,11 +141541,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -141557,7 +141557,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -141566,19 +141566,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -141591,16 +141591,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -141608,7 +141608,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141624,7 +141624,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -141663,11 +141663,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141743,14 +141743,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint32(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141776,10 +141776,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141794,30 +141794,30 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z goto _30 } if p > int32(z)-int32(a)+BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) { - v34 = p + v5 = p } else { - v34 = int32(z) - int32(a) + BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) + v5 = int32(z) - int32(a) + BoolInt32(!(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0)) } - p = v34 + p = v5 goto _30 goto narrow_c narrow_c: ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*uint8)(unsafe.Pointer(v35)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141831,24 +141831,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) + v8 = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) } else { - v39 = __ccgo_ts + 1460 + v8 = __ccgo_ts + 1460 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint32FromInt32(v5))) if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(z) - int32(a) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141862,23 +141862,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) - v42 = Int32FromInt32(0) - l = v42 - i = Uint32FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint32FromInt32(v5) for { if v45 = i < Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint32FromInt32(l) <= Uint32FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) } if l < 0 { return -int32(1) @@ -141891,28 +141891,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) i = uint32(0) for { - if v49 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < 0+Uint32FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint32FromInt32(v47) <= Uint32FromInt32(p)) { + if !(v45 && i+Uint32FromInt32(v5) <= Uint32FromInt32(p)) { break } _out(tls, f, bp+48, Uint32FromInt32(l)) goto _46 _46: ; - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) } _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141977,7 +141977,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141986,7 +141986,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint32(NL_ARGMAX) { goto inval @@ -142012,12 +142012,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+4 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 4)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -142056,11 +142056,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint32(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -142114,7 +142114,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142128,17 +142128,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -142161,99 +142161,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 4 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 4 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 4 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -142264,33 +142264,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -142344,14 +142344,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -142369,85 +142369,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 4 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 4 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint32(257)) @@ -142461,10 +142461,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -142472,11 +142472,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint32(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -142488,36 +142488,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint32(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = v63 + k = v59 if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint32(4)) @@ -142530,16 +142530,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 4 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142550,12 +142550,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp = Xrealloc(tls, wcs, k*uint32(4)) if !(tmp != 0) { goto alloc_fail @@ -142574,23 +142574,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 4 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v73))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -142599,40 +142599,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 4 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 4 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v79))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 4 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 4 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142640,7 +142640,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142663,26 +142663,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142697,15 +142697,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -142714,6 +142706,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142729,20 +142729,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(f)).Frpos)-int32((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142754,7 +142754,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142763,7 +142763,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142935,7 +142935,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142992,7 +142992,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -143000,7 +143000,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+16 */ [16]uint8 var _ /* s at bp+4 */ uintptr var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 4)) = fmt l10n = uint32(0) cnt = 0 @@ -143013,7 +143013,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) != 0) { break } @@ -143037,7 +143037,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 } if (int32(z)-int32(a))/4 > int32(INT_MAX)-cnt { goto overflow @@ -143052,7 +143052,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4)) == uint32('$') { l10n = uint32(1) argpos = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4)) - uint32('0')) - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 4)) += 4 @@ -143063,7 +143063,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)))) - uint32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4))))-uint32(' ')) goto _4 _4: ; @@ -143075,7 +143075,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 1*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -143090,13 +143090,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+4) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+4) + w = v5 + if v5 < 0 { goto overflow } } @@ -143105,16 +143105,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 3*4)) == uint32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + 2*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 4)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 4)) = *(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(2)*4 } else { goto inval } @@ -143170,7 +143170,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 4)) + uintptr(-Int32FromInt32(1))*4))) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -143212,11 +143212,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint32FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -143237,27 +143237,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) = __ccgo_ts + 1460 } bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -143272,13 +143272,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(&*(*Targ)(unsafe.Pointer(bp + 8)))) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+32, bs, uint32(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+32, uint32(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -143330,7 +143330,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -143339,7 +143339,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -143431,7 +143431,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -143474,7 +143474,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if Uint32FromInt32(c) == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -143495,14 +143495,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -143527,23 +143527,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 4 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 4 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143554,37 +143554,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 4 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 4 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if Uint32FromInt32(c) != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 4 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143593,7 +143593,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -143603,7 +143603,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('$') { dest = _arg_n1(tls, ap, *(*Twchar_t)(unsafe.Pointer(p))-uint32('0')) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -143614,8 +143614,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + *(*Twchar_t)(unsafe.Pointer(p)) - uint32('0')) - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -143628,9 +143628,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case uint32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('h') { p += 4 @@ -143702,45 +143702,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 4 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 4 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 4 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143767,8 +143767,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == uint32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == uint32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143787,17 +143787,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143805,11 +143805,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint32(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = v35 + k = v4 if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint32(4)) if !(wcs != 0) { @@ -143824,27 +143824,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 4 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 4 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = Uint32FromInt32(c) + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) if alloc != 0 && i == k { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp1 = Xrealloc(tls, wcs, k*uint32(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143854,17 +143854,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, Uint32FromInt32(c)) + l = Xwctomb(tls, v5, Uint32FromInt32(c)) if l < 0 { goto input_fail } - i += Uint32FromInt32(l) + i = i + Uint32FromInt32(l) if alloc != 0 && i > k-uint32(4) { - k += k + uint32(1) + k = k + (k + uint32(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143873,16 +143873,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 4 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 4 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143940,23 +143940,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint32(22), __ccgo_ts+1503, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1521, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143964,7 +143964,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143976,7 +143976,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143985,7 +143985,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -144066,8 +144066,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint32 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint32 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint32FromInt32(int32((*TFILE)(unsafe.Pointer(f)).Fwpos)-int32((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144081,11 +144081,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 4)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { _memcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -144206,11 +144206,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -144228,9 +144228,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint32FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint32FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) @@ -144244,9 +144244,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint32FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -144291,9 +144291,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint32(0) @@ -144311,10 +144311,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint32(0) } - v3 = f + 4 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 4 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint32(1) } @@ -144433,9 +144433,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144446,27 +144446,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int32) { @@ -144474,9 +144474,9 @@ func Xatol(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144487,27 +144487,27 @@ func Xatol(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - int32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatoll(tls *TLS, s uintptr) (r int64) { @@ -144529,19 +144529,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144566,11 +144566,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint32(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint32(2) + nel = nel / uint32(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint32(2) + uint32(1) + nel = nel - (nel/uint32(2) + uint32(1)) } else { return try } @@ -144597,9 +144597,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]uint8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -144616,9 +144616,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144812,9 +144812,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144823,7 +144823,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { - n = int32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) + n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint32(0) } @@ -144834,7 +144834,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint32FromInt32(n) >= Uint32FromInt32(8)*Uint32FromInt64(4) { - n = int32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) + n = Int32FromUint32(uint32(n) - Uint32FromInt32(8)*Uint32FromInt64(4)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*4)) *(*Tsize_t)(unsafe.Pointer(p + 1*4)) = uint32(0) } @@ -144846,10 +144846,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(240) defer tls.Free(240) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [57]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[57]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144860,16 +144860,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[57]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[57]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144900,12 +144900,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[57]uintptr)(unsafe.Pointer(bp + 8)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144952,13 +144952,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0]&uint32(3) == uint32(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+192, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint32FromInt32(int32(high)-int32(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) @@ -144974,17 +144974,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+192, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[0] != uint32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 192)))[int32(1)] != uint32(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+192) _shr(tls, bp+192, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+192, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 192)) ^= uint32(7) _shr(tls, bp+192, int32(1)) _trinkle(tls, head-uintptr((*(*[48]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift+int32(1), int32(1), bp) @@ -144992,7 +144992,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 192)) |= uint32(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+192, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -145023,9 +145023,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(144) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -145035,11 +145035,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145212,7 +145212,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145220,7 +145220,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint32(1) } @@ -145231,11 +145231,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(208) defer tls.Free(208) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145256,11 +145256,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp+64)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145316,7 +145316,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145324,7 +145324,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 4 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint32(1) } @@ -145335,11 +145335,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(208) defer tls.Free(208) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145360,11 +145360,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint32FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + int64(int32((*TFILE)(unsafe.Pointer(bp+64)).Frpos)-int32((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145474,9 +145474,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -145492,9 +145492,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 { goto tail @@ -145510,7 +145510,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -145518,19 +145518,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145569,8 +145569,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) @@ -145583,7 +145583,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 4 - n -= Uint32FromInt64(4) + n = n - Uint32FromInt64(4) } s = w } @@ -145594,8 +145594,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -145622,9 +145622,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -145636,12 +145636,12 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -145783,29 +145783,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -145840,22 +145840,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint32(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint32(0) goto _9 } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145863,10 +145863,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint32(0) goto _9 } @@ -145879,12 +145879,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145914,7 +145914,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint32(1) { return h } - k -= Uint32FromInt32(int32(h) - int32(h0)) + k = k - Uint32FromInt32(int32(h)-int32(h0)) if k < l { return uintptr(0) } @@ -145939,9 +145939,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145954,14 +145954,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for uint32(d)%Uint32FromInt64(4) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } for { @@ -145972,42 +145972,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint32FromInt64(4) - d += uintptr(Uint32FromInt64(4)) - s += uintptr(Uint32FromInt64(4)) + n = n - Uint32FromInt64(4) + d = d + uintptr(Uint32FromInt64(4)) + s = s + uintptr(Uint32FromInt64(4)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for uint32(d+uintptr(n))%Uint32FromInt64(4) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint32FromInt64(4) { - n -= Uint32FromInt64(4) + n = n - Uint32FromInt64(4) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } } @@ -146034,7 +146034,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -146092,9 +146092,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint32(s) & uint32(3) - s += uintptr(k) - n -= k - n &= Uint32FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint32FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -146125,8 +146125,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint32(24) + uint32(s)&uint32(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -146142,8 +146142,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint32(32) - s += uintptr(32) + n = n - uint32(32) + s = s + uintptr(32) } return dest } @@ -146173,8 +146173,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 uint8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 uint8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint32(s)%Uint32FromInt64(4) == uint32(d)%Uint32FromInt64(4) { for { if !(uint32(s)%Uint32FromInt64(4) != 0) { @@ -146188,8 +146188,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -146210,16 +146210,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -146258,9 +146258,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) == uint32(d)&(Uint32FromInt64(4)-Uint32FromInt32(1)) { for { if v3 = uint32(s)&(Uint32FromInt64(4)-Uint32FromInt32(1)) != 0 && n != 0; v3 { @@ -146273,9 +146273,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { goto tail @@ -146290,7 +146290,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -146298,19 +146298,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -146352,8 +146352,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146392,7 +146392,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146455,7 +146455,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(UCHAR_MAX) * Uint32FromInt32(c) w = s @@ -146476,7 +146476,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146510,8 +146510,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146532,10 +146532,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [8]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { return Uint32FromInt32(int32(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int32(a)) @@ -146543,16 +146543,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint32(32)) for { if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + v2 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0)) { @@ -146561,7 +146561,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } @@ -146643,12 +146643,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 uint8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 uint8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146664,9 +146664,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146679,7 +146679,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint32(4) + n = n - uint32(4) ws += 4 wd += 4 } @@ -146688,19 +146688,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*uint8)(unsafe.Pointer(d)) = uint8(0) goto finish @@ -146739,7 +146739,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146759,7 +146759,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } @@ -146775,7 +146775,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146786,9 +146786,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146814,21 +146814,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + v1 = d + d = d + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) return a } @@ -146843,7 +146843,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146854,9 +146854,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146912,7 +146912,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*uint8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146943,7 +146943,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { end = uintptr(0) @@ -146969,7 +146969,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -146980,12 +146980,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -146997,10 +146997,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [8]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[8]Tsize_t)(unsafe.Pointer(bp)) = [8]Tsize_t{} if !(*(*uint8)(unsafe.Pointer(c)) != 0) { @@ -147014,22 +147014,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } for { if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) + v3 = bp + uintptr(uint32(*(*uint8)(unsafe.Pointer(c)))/(Uint32FromInt32(8)*Uint32FromInt64(4)))*4 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint32FromInt32(1) << (uint32(*(*uint8)(unsafe.Pointer(c))) % (Uint32FromInt32(8) * Uint32FromInt64(4))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[8]Tsize_t)(unsafe.Pointer(bp)))[uint32(*(*uint8)(unsafe.Pointer(s)))/(Uint32FromInt32(8)*Uint32FromInt64(4))]&(Uint32FromInt32(1)<<(uint32(*(*uint8)(unsafe.Pointer(s)))%(Uint32FromInt32(8)*Uint32FromInt64(4)))) != 0) { @@ -147038,18 +147038,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint32FromInt32(int32(s) - int32(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147181,29 +147181,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147240,7 +147240,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -147250,22 +147250,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint32(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint32(0) goto _9 } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -147273,10 +147273,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint32(0) goto _9 } @@ -147289,12 +147289,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -147342,9 +147342,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -147352,17 +147352,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v1 = _p2 + _p2 = _p2 + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147376,9 +147376,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147386,18 +147386,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147440,7 +147440,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147456,7 +147456,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147485,12 +147485,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int32(2) + n = n - int32(2) } } @@ -147690,7 +147690,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147703,7 +147703,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) - Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r)))) } @@ -147721,21 +147721,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = uint32(0) + *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) return a } @@ -147753,7 +147753,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147779,7 +147779,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147811,7 +147811,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147866,10 +147866,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint32 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint32(0) for { @@ -147879,7 +147879,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147893,23 +147893,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint32FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147918,29 +147918,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint32FromInt32(-Int32FromInt32(1)) jp = uint32(0) - v5 = Uint32FromInt32(1) - p = v5 - k = v5 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint32(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint32(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint32FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint32FromInt32(1) + p = v2 + k = v2 } } } @@ -147977,16 +147977,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint32(1) > mem { - v11 = ms + uint32(1) + v8 = ms + uint32(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -147994,10 +147994,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint32(0) goto _9 } @@ -148010,12 +148010,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -148051,9 +148051,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -148061,18 +148061,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = uint32(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -148101,7 +148101,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -148126,7 +148126,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148154,7 +148154,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148173,8 +148173,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -148182,7 +148182,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint32(d)-uint32(s) < n*uint32(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148190,9 +148190,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -148216,7 +148216,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148249,7 +148249,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148274,27 +148274,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint32(6) || Uint32FromInt32(len1) > l-uint32(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1563, uint32(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148357,7 +148357,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148568,7 +148568,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148619,38 +148619,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148658,15 +148658,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(Int32FromUint8(_days_in_month[months]) <= remdays) { break } - remdays -= Int32FromUint8(_days_in_month[months]) + remdays = remdays - Int32FromUint8(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148712,19 +148712,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148761,7 +148761,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148771,20 +148771,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148803,21 +148803,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148828,7 +148828,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148840,10 +148840,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148857,7 +148857,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148883,13 +148883,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += x * uint32(*(*uint8)(unsafe.Pointer(v))) + y = y + x*uint32(*(*uint8)(unsafe.Pointer(v))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148899,12 +148899,12 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v6, v7 int32 + var posix_form, scale, v2, v6 int32 var _ /* buf at bp+6 */ [280]uint8 var _ /* dummy_name at bp+301 */ [7]uint8 var _ /* p at bp+292 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1570) @@ -148928,7 +148928,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148942,7 +148942,7 @@ func _do_tzset(tls *TLS) { i = Uint32FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint32(2) + _old_tz_size = _old_tz_size * uint32(2) if i >= _old_tz_size { _old_tz_size = i + uint32(1) } @@ -148967,7 +148967,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1573) != 0) { @@ -148989,7 +148989,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint32(1)) + try = try + uintptr(l+uint32(1)) } } } @@ -149016,7 +149016,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint32(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -149033,18 +149033,18 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = v7 - Xtimezone = v6 - Xdaylight = v6 + v6 = Int32FromInt32(0) + _dst_off = v6 + v2 = v6 + Xtimezone = v2 + Xdaylight = v2 p1 = _types for { if !(p1 < _abbrevs) { @@ -149062,7 +149062,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -149097,11 +149097,11 @@ func _do_tzset(tls *TLS) { _dst_off = Xtimezone } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149139,10 +149139,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint32(1)))))))) } if t-int64(off) < Int64FromUint64(x) { - n /= uint32(2) + n = n / uint32(2) } else { a = m - n -= n / uint32(2) + n = n - n/uint32(2) } } /* First and last entry are special. First means to use lowest-index @@ -149171,7 +149171,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint32(6) + i = i - uint32(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -149222,25 +149222,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -149283,16 +149283,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += int64(Xtimezone) - t1 += int64(_dst_off) + t0 = t0 + int64(Xtimezone) + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -149365,7 +149365,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -149382,8 +149382,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149393,15 +149393,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149411,11 +149411,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149905,9 +149905,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+36, bp+44, bp+40) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= int64(*(*int32)(unsafe.Pointer(bp + 44)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64(*(*int32)(unsafe.Pointer(bp + 44))-(*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) + t = t - int64((*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) if t != t { goto error } @@ -149935,9 +149935,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149948,7 +149948,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149957,7 +149957,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149981,10 +149981,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1495 width = int32(2) def_pad = int32('0') @@ -150038,14 +150038,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -150062,7 +150062,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -150093,11 +150093,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint32(0) @@ -150106,14 +150106,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -150137,11 +150137,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -150201,11 +150201,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint32FromInt32(Xsnprintf(tls, s, uint32(100), __ccgo_ts+1687, VaList(bp+8, val))) case int32('_'): @@ -150247,15 +150247,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(112) defer tls.Free(112) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint32 var v9 bool var _ /* buf at bp+4 */ [100]uint8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+104 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint32(0) for { if !(l < n) { @@ -150267,21 +150267,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+104, int32(10)) @@ -150298,7 +150298,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 104)) if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+4, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -150309,8 +150309,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -150319,8 +150319,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -150333,50 +150333,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v7))) = uint8('-') - width-- + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 104))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v8) { - v10 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v10))) = uint8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint32FromInt32(v4) { + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v12))) = uint8('0') + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } _memcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -150410,15 +150410,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+12 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -150442,21 +150442,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint32(Xstrtoul(tls, f, bp+12, int32(10))) @@ -150466,7 +150466,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150563,7 +150563,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150618,19 +150618,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*uint8)(unsafe.Pointer(s)) != 0; v48 { - v45 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150642,7 +150642,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150650,7 +150650,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150714,7 +150714,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150727,9 +150727,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150748,13 +150748,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150769,30 +150769,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150812,13 +150812,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -151074,7 +151074,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(512) defer tls.Free(512) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint32 @@ -151082,7 +151082,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+504 */ uintptr var _ /* wbuf at bp+104 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint32(0) for { if !(l < n) { @@ -151094,7 +151094,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != uint32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -151140,40 +151140,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = uint32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = uint32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = uint32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151326,8 +151326,8 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { trc("tls=%v old=%v new1=%v flags=%v, (%v:)", tls, old, new1, flags, origin(2)) defer func() { trc("-> %v", r1) }() } - var r, v1, v2 int32 - _, _, _ = r, v1, v2 + var r, v1 int32 + _, _ = r, v1 if old == new1 { return X__syscall_ret(tls, Uint32FromInt32(-Int32FromInt32(EINVAL))) } @@ -151347,9 +151347,9 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) - r = v2 - if !(v2 == -int32(EBUSY)) { + v1 = int32(X__syscall2(tls, int32(SYS_dup2), old, new1)) + r = v1 + if !(v1 == -int32(EBUSY)) { break } } @@ -151580,7 +151580,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*uint8)(unsafe.Pointer(name + uintptr(i-uint32(1)))) = uint8(0) @@ -151743,7 +151743,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_arm64.go b/vendor/modernc.org/libc/ccgo_linux_arm64.go index aef720a..185c7d1 100644 --- a/vendor/modernc.org/libc/ccgo_linux_arm64.go +++ b/vendor/modernc.org/libc/ccgo_linux_arm64.go @@ -588,14 +588,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -604,8 +604,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -936,18 +936,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -979,9 +979,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -1031,9 +1031,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1077,18 +1077,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1096,18 +1096,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1166,8 +1166,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1188,42 +1188,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1237,11 +1237,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1251,17 +1251,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1272,11 +1272,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1289,17 +1289,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1312,11 +1312,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1328,8 +1328,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1345,92 +1345,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1463,14 +1463,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1484,32 +1484,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1528,11 +1528,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1547,12 +1547,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1564,32 +1564,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1608,11 +1608,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1879,18 +1879,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1898,18 +1898,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1922,8 +1922,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1944,42 +1944,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1993,11 +1993,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2006,17 +2006,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2027,11 +2027,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2046,17 +2046,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2069,11 +2069,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2085,8 +2085,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2102,92 +2102,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2231,13 +2231,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2252,29 +2252,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2305,8 +2305,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2314,22 +2314,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2351,13 +2351,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2372,29 +2372,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2402,21 +2402,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2430,18 +2430,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2464,18 +2464,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2483,18 +2483,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2505,15 +2505,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2556,15 +2556,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2607,11 +2607,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2621,15 +2621,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2654,50 +2654,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7371,13 +7371,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7433,14 +7433,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7455,14 +7455,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= X__libc.Fpage_size + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7471,7 +7471,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -8847,16 +8847,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8865,10 +8865,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8877,16 +8877,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8895,16 +8895,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8913,58 +8913,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -8984,7 +8984,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -8995,12 +8995,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9008,36 +9008,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9045,9 +9045,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9056,10 +9056,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9106,9 +9106,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9125,25 +9125,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9154,11 +9154,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9183,7 +9183,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9196,7 +9196,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9213,13 +9213,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9232,7 +9232,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9257,7 +9257,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9265,7 +9265,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9284,9 +9284,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9295,7 +9295,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] @@ -11178,7 +11178,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11205,14 +11205,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11222,8 +11222,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11258,35 +11258,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11299,10 +11299,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11316,19 +11316,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11339,7 +11339,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11355,10 +11355,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11367,7 +11367,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11377,23 +11377,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11424,12 +11424,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11439,10 +11439,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11462,11 +11462,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11481,11 +11481,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11497,12 +11497,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11711,7 +11711,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11719,60 +11719,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11785,7 +11785,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -11829,7 +11829,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -11846,8 +11846,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -11858,8 +11858,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -11899,15 +11899,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -11938,7 +11938,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -11977,7 +11977,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12007,13 +12007,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v5)) = uint8('$') i = uint32(0) for { @@ -12024,7 +12024,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -12224,7 +12224,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12234,7 +12234,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12262,7 +12262,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12279,7 +12279,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12327,7 +12327,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12344,8 +12344,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12356,8 +12356,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12369,15 +12369,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12401,7 +12401,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12444,7 +12444,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12477,7 +12477,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12504,7 +12504,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12518,7 +12518,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12532,7 +12532,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12562,11 +12562,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12576,7 +12576,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -12886,7 +12886,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12903,8 +12903,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -12915,8 +12915,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -12928,15 +12928,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12960,7 +12960,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -12988,7 +12988,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13013,7 +13013,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13046,7 +13046,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13073,7 +13073,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13087,7 +13087,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13101,7 +13101,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13131,11 +13131,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13145,7 +13145,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -13293,9 +13293,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13307,18 +13307,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17440,8 +17440,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22158,7 +22158,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22197,10 +22197,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22266,15 +22266,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22285,15 +22285,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -24850,10 +24850,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -24888,16 +24888,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -24967,7 +24967,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25086,7 +25086,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25188,7 +25188,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25200,7 +25200,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25645,7 +25645,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25669,7 +25669,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25713,7 +25713,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -25968,15 +25968,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -25985,23 +25985,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26011,18 +26011,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26030,58 +26030,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26106,7 +26106,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26116,32 +26116,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26157,7 +26157,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26166,15 +26166,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26185,14 +26185,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26202,7 +26202,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26210,11 +26210,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26246,12 +26246,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26276,19 +26276,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26301,24 +26301,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26379,7 +26379,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26390,11 +26390,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26406,29 +26406,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26441,40 +26441,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26501,11 +26501,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26519,7 +26519,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26535,26 +26535,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26566,15 +26566,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26598,41 +26598,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26644,15 +26644,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26662,10 +26662,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26679,13 +26679,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26697,11 +26697,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26713,10 +26713,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26735,7 +26735,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26751,16 +26751,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -26769,24 +26769,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -26794,12 +26794,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -26813,55 +26813,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -26869,26 +26869,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26896,19 +26896,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27182,11 +27182,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27197,7 +27197,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27215,42 +27215,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27269,7 +27269,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27283,18 +27283,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27302,18 +27302,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27327,18 +27327,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27461,7 +27461,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') @@ -27476,21 +27476,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27533,7 +27533,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28258,7 +28258,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28465,7 +28465,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && Int32FromUint8(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = uint8(0) } @@ -28958,7 +28958,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30123,7 +30123,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31085,8 +31085,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31106,10 +31106,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31198,10 +31198,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98112,7 +98112,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98120,8 +98120,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98145,16 +98145,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98221,23 +98221,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98278,10 +98278,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98299,10 +98299,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98312,7 +98312,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]uint8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98500,11 +98500,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98517,7 +98517,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98526,27 +98526,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98572,11 +98572,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98635,8 +98635,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98649,7 +98649,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -98673,7 +98673,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -98698,13 +98698,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -98722,17 +98722,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98741,9 +98741,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -98760,18 +98760,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -98843,7 +98843,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -98861,17 +98861,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98962,7 +98962,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -98982,7 +98982,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*uint8)(unsafe.Pointer(v54)) = uint8(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -99000,7 +99000,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99009,17 +99009,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99031,24 +99031,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v57)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v60)) = uint8(v62) + *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99057,7 +99057,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99067,14 +99067,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*uint8)(unsafe.Pointer(v63)) = uint8(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*uint8)(unsafe.Pointer(v65)) = uint8(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99086,56 +99086,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*uint8)(unsafe.Pointer(v67)) = uint8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*uint8)(unsafe.Pointer(v69)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*uint8)(unsafe.Pointer(v71)) = uint8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*uint8)(unsafe.Pointer(v73)) = uint8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*uint8)(unsafe.Pointer(v75)) = uint8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*uint8)(unsafe.Pointer(v77)) = uint8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*uint8)(unsafe.Pointer(v79)) = uint8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*uint8)(unsafe.Pointer(v81)) = uint8(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*uint8)(unsafe.Pointer(v83)) = uint8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*uint8)(unsafe.Pointer(v85)) = uint8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*uint8)(unsafe.Pointer(v87)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99146,38 +99146,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*uint8)(unsafe.Pointer(v89)) = uint8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*uint8)(unsafe.Pointer(v91)) = uint8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*uint8)(unsafe.Pointer(v93)) = uint8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*uint8)(unsafe.Pointer(v95)) = uint8(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*uint8)(unsafe.Pointer(v97)) = uint8(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*uint8)(unsafe.Pointer(v99)) = uint8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*uint8)(unsafe.Pointer(v101)) = uint8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*uint8)(unsafe.Pointer(v103)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99208,7 +99208,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99285,8 +99285,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99300,11 +99300,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 522 + v1 = __ccgo_ts + 522 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99341,13 +99341,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99416,11 +99416,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]uint8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*uint8)(unsafe.Pointer(val)) != 0) { @@ -99449,7 +99449,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 531 @@ -99517,11 +99517,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99625,7 +99625,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99653,7 +99653,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -99730,7 +99730,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -99741,7 +99741,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99851,7 +99851,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -99865,7 +99865,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -99909,7 +99909,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99965,10 +99965,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]uint8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100004,7 +100004,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100017,7 +100017,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -100028,22 +100028,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + s = s - 1 + v3 = s + *(*uint8)(unsafe.Pointer(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100056,11 +100056,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 522 + v3 = __ccgo_ts + 522 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100094,9 +100094,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100110,15 +100110,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100130,9 +100130,9 @@ _4: for { switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100153,7 +100153,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100164,13 +100164,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100179,12 +100179,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100193,12 +100193,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100209,8 +100209,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100405,9 +100405,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100420,11 +100420,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100624,12 +100624,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100649,11 +100649,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101034,12 +101034,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101164,10 +101164,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101195,8 +101195,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101210,17 +101210,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101240,18 +101240,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101264,7 +101264,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101283,7 +101283,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101297,7 +101297,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101309,11 +101309,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101324,7 +101324,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101338,37 +101338,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101382,11 +101382,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101400,17 +101400,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101432,18 +101432,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101455,38 +101455,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101502,7 +101502,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101518,7 +101518,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101526,11 +101526,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101596,13 +101596,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -101759,12 +101759,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -101806,11 +101806,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102462,11 +102462,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102481,14 +102481,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102566,11 +102566,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -102683,11 +102683,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -102823,11 +102823,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -102991,12 +102991,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103034,8 +103034,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103286,7 +103286,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103295,7 +103295,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103312,10 +103312,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103435,12 +103435,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103476,11 +103476,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -103754,7 +103754,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -103789,12 +103789,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -103821,11 +103821,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -103939,7 +103939,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -103974,12 +103974,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104006,11 +104006,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104046,11 +104046,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104137,13 +104137,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104336,11 +104336,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104416,14 +104416,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104431,13 +104431,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104491,9 +104491,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104518,13 +104518,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104623,13 +104623,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -104764,7 +104764,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -104842,7 +104842,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -104899,7 +104899,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -104945,12 +104945,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -104959,8 +104959,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105002,13 +105002,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105017,10 +105017,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105038,13 +105038,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105053,10 +105053,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105272,7 +105272,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105284,10 +105284,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105399,7 +105399,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) // __asm__("clz %0, %1" : "=r"(x) : "r"(x)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 80, __ccgo_ts+566) @@ -105411,13 +105411,13 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105428,7 +105428,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { return float64(x1*y) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105461,7 +105461,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) - r += float64(Tdouble_t(tiny*tiny) * (r - r)) + r = r + float64(Tdouble_t(tiny*tiny)*(r-r)) } } else { /* only round once when scaled */ @@ -105494,13 +105494,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105509,27 +105509,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105537,11 +105537,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105551,13 +105551,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105566,27 +105566,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105594,11 +105594,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105616,13 +105616,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105631,27 +105631,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105659,11 +105659,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -105673,13 +105673,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105688,27 +105688,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -105716,11 +105716,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -105742,7 +105742,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -105755,7 +105755,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105803,13 +105803,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -105862,17 +105862,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106003,17 +106003,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106034,12 +106034,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106063,10 +106063,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106078,12 +106078,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106107,10 +106107,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106147,7 +106147,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106160,7 +106160,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106178,10 +106178,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106221,13 +106221,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106302,13 +106302,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106371,8 +106371,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106423,7 +106423,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106445,8 +106445,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106542,7 +106542,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -106698,7 +106698,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -106806,7 +106806,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -106886,7 +106886,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107031,7 +107031,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107139,7 +107139,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107230,7 +107230,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107377,7 +107377,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107484,7 +107484,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107566,7 +107566,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107708,7 +107708,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -107815,7 +107815,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -107855,7 +107855,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -107869,14 +107869,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -107919,7 +107919,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -107943,12 +107943,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -107961,8 +107961,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -107977,7 +107977,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108002,7 +108002,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108015,14 +108015,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108049,15 +108049,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108123,7 +108123,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108133,11 +108133,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108151,7 +108151,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108162,14 +108162,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108183,7 +108183,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108206,12 +108206,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108223,8 +108223,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108239,7 +108239,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108264,7 +108264,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108277,14 +108277,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108310,13 +108310,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108353,7 +108353,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108362,11 +108362,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108475,8 +108475,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108582,7 +108582,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108590,11 +108590,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108606,20 +108606,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -108733,7 +108733,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -108839,7 +108839,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -108847,11 +108847,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -108863,20 +108863,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109004,9 +109004,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109032,31 +109032,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109156,8 +109156,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109352,7 +109352,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109362,7 +109362,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109452,7 +109452,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109462,7 +109462,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -109511,9 +109511,9 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109536,31 +109536,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110179,9 +110179,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110279,9 +110279,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110338,8 +110338,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110353,7 +110353,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110382,32 +110382,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110537,12 +110537,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110629,16 +110629,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -110708,11 +110708,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, x2 Tdouble_t var ix, iy Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -110731,19 +110731,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -110757,14 +110757,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -110776,43 +110776,43 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111244,8 +111244,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111253,10 +111253,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111264,10 +111264,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111351,13 +111351,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111415,8 +111415,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111424,10 +111424,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111435,10 +111435,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111713,13 +111713,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -111735,10 +111735,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -111764,13 +111764,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -111786,10 +111786,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -111861,11 +111861,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -111874,11 +111874,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -111905,22 +111905,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -111966,12 +111966,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -111986,18 +111986,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112029,14 +112029,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112052,18 +112052,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112076,9 +112076,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112124,13 +112124,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112146,18 +112146,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112188,11 +112188,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112208,24 +112208,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112286,13 +112286,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112306,18 +112306,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112348,11 +112348,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112522,9 +112522,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112543,7 +112543,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112552,7 +112552,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112580,9 +112580,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -112692,7 +112692,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -112727,9 +112727,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -112739,13 +112739,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -112771,11 +112771,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -112790,18 +112790,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112837,13 +112837,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112857,18 +112857,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112885,28 +112885,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113104,8 +113104,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113205,7 +113205,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113218,7 +113218,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113288,7 +113288,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113301,10 +113301,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113315,7 +113315,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113462,12 +113462,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*uint8)(unsafe.Pointer(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) @@ -113518,7 +113518,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113527,7 +113527,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113561,7 +113561,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113573,7 +113573,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113585,7 +113585,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) return s @@ -113679,7 +113679,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -113694,11 +113694,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -113791,17 +113791,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == uint32(':') { @@ -114080,11 +114080,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114136,7 +114136,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114165,7 +114165,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114182,7 +114182,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114190,9 +114190,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114207,11 +114207,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114222,11 +114222,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114243,22 +114243,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114284,7 +114284,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+720, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114300,13 +114300,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 789 + v5 = __ccgo_ts + 789 } else { - v6 = __ccgo_ts + 696 + v5 = __ccgo_ts + 696 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114367,9 +114367,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint64 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall4(tls, int64(SYS_prlimit64), int64(Int32FromInt32(0)), int64(resource), int64(Int32FromInt32(0)), int64(rlim))))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114392,11 +114392,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114448,7 +114448,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114473,7 +114473,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -114761,15 +114761,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -114779,12 +114779,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -114832,7 +114832,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114975,28 +114975,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*uint8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115006,29 +115006,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*uint8)(unsafe.Pointer(v7)) = cval + v1 = dest + dest = dest + 1 + *(*uint8)(unsafe.Pointer(v1)) = cval src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } } *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -115077,7 +115077,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+825, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115135,15 +115135,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(176) defer tls.Free(176) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+160 */ TFTW var _ /* new at bp+128 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115195,11 +115195,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel if h != 0 { @@ -115213,7 +115213,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115222,7 +115222,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) } @@ -115237,10 +115237,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115278,9 +115278,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115292,11 +115292,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115469,7 +115469,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115482,12 +115482,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]uint8 var _ /* stack at bp+0 */ [4097]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115522,27 +115522,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') - p++ + p = p + 1 /* Initial // is special. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v5] = uint8('/') + v4 = q + q = q + 1 + (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115552,17 +115552,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v7] = uint8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) - p += l + p = p + l up = 0 if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115571,8 +115571,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115601,23 +115601,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115625,10 +115625,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115636,7 +115636,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115650,26 +115650,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v11] = uint8('/') + v4 = l + l = l + 1 + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116193,19 +116193,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]uint8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116223,12 +116223,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v2] = uint8('\n') + v1 = l + l = l + 1 + (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+649, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116481,7 +116481,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -116726,11 +116726,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -116769,9 +116769,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -116780,10 +116780,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -116945,12 +116945,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Uint32FromInt32(Int32FromInt32(0xdfff) & int32(Int8FromUint32(c))) + wn = wn - 1 goto _4 _4: } @@ -116965,44 +116965,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117022,76 +117022,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = uint32(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = uint32(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = uint32(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = uint32(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = uint32(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = uint32(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117240,31 +117240,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if wc < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xc0) | wc>>Int32FromInt32(6)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(2) } else { if wc < uint32(0xd800) || wc-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(3) } else { if wc-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(12)&uint32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32(0x80) | wc>>Int32FromInt32(6)&uint32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = uint8(uint32(0x80) | wc&uint32(0x3f)) return uint64(4) } @@ -117310,16 +117310,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117335,9 +117335,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]uint8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117351,9 +117351,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117373,13 +117373,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117398,13 +117398,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118519,9 +118519,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118532,8 +118532,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118545,20 +118545,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -118571,34 +118571,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -118612,17 +118612,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -118673,22 +118673,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -118710,9 +118710,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -118748,26 +118748,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*uint8)(unsafe.Pointer(v3)) = uint8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) } } else { *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -118780,7 +118780,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -118815,7 +118815,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -118925,9 +118925,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -118939,31 +118939,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -118971,7 +118971,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119313,7 +119313,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119325,7 +119325,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119365,11 +119365,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 976 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119412,9 +119412,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119423,15 +119423,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119448,7 +119448,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -119460,16 +119460,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -119572,7 +119572,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -119642,13 +119642,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -119779,7 +119779,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119844,15 +119844,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -119902,7 +119902,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119961,41 +119961,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120257,7 +120257,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120438,17 +120438,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120461,29 +120461,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8('.') - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+1007) } @@ -120493,15 +120493,15 @@ var _xdigits = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1016, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120516,7 +120516,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120534,14 +120534,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120554,35 +120554,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*uint8)(unsafe.Pointer(p)) != 0; v13 { - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*uint8)(unsafe.Pointer(z)) != 0; v18 { - v15 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { @@ -120596,7 +120596,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -120604,7 +120604,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]uint8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1040, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -120614,7 +120614,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120632,14 +120632,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -120739,7 +120739,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8('%') Xstrcat(tls, bp+78, p) @@ -120844,7 +120844,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -120923,12 +120923,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(32) defer tls.Free(32) - var r, v17, v26, v8 int64 - var r1, v1, v10, v19 int32 + var r, v8 int64 + var r1, v1 int32 var tv uintptr - var v11, v12, v13, v14, v15, v16, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7 Tsyscall_arg_t + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t var _ /* tv32 at bp+8 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) v2 = int64(fd) @@ -120972,27 +120972,27 @@ _9: *(*[1]Tsocklen_t)(unsafe.Pointer(bp)) = [1]Tsocklen_t{ 0: uint32(16), } - v10 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v11 = int64(fd) - v12 = int64(level) - v13 = int64(optname) - v14 = int64(bp + 8) - v15 = int64(bp) - v16 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp + 8) + v6 = int64(bp) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v17 = r + v8 = r goto _18 } - v17 = r + v8 = r goto _18 _18: - r1 = int32(v17) + r1 = int32(v8) if r1 < 0 { break } @@ -121012,27 +121012,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v19 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v20 = int64(fd) - v21 = int64(level) - v22 = int64(optname) - v23 = int64(optval) - v24 = int64(optlen) - v25 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = int64(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v26 = r + v8 = r goto _27 } - v26 = r + v8 = r goto _27 _27: - r1 = int32(v26) + r1 = int32(v8) break } } @@ -121082,7 +121082,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -121094,16 +121094,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121274,7 +121274,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121320,14 +121320,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121349,9 +121349,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121361,11 +121361,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121413,7 +121413,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121443,7 +121443,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -121470,12 +121470,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Uint8FromUint8(':') @@ -121602,7 +121602,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -121616,11 +121616,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -121641,7 +121641,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -121653,11 +121653,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -121667,7 +121667,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { @@ -121678,9 +121678,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*uint8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -121688,22 +121688,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -121720,15 +121720,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -121741,7 +121741,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -121749,16 +121749,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -121837,7 +121837,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -121887,14 +121887,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -121902,23 +121902,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -121927,9 +121927,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -121947,14 +121947,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -121977,15 +121977,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122004,7 +122004,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122012,26 +122012,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*uint8)(unsafe.Pointer(p)) != 0; v17 { - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*uint8)(unsafe.Pointer(v18)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122043,35 +122043,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*uint8)(unsafe.Pointer(p)) != 0; v23 { - v20 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*uint8)(unsafe.Pointer(z)) != 0; v28 { - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { @@ -122081,11 +122081,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122132,7 +122132,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122177,14 +122177,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122206,7 +122206,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122221,7 +122221,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122246,13 +122246,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]uint8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122266,19 +122266,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*uint8)(unsafe.Pointer(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122309,23 +122309,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122411,7 +122411,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -122447,7 +122447,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -122467,7 +122467,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -122477,7 +122477,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*uint8)(unsafe.Pointer(canon)) = uint8(0) if name != 0 { @@ -122495,7 +122495,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -122529,7 +122529,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -122538,18 +122538,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -122567,7 +122567,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -122586,7 +122586,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -122640,31 +122640,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122811,19 +122811,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*uint8)(unsafe.Pointer(p)) != 0; v19 { - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -122835,9 +122835,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1059, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -122845,18 +122845,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123019,34 +123019,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123061,21 +123061,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123088,14 +123088,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123122,7 +123122,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123133,18 +123133,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123161,8 +123161,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123197,22 +123197,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123223,7 +123223,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123346,7 +123346,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -123443,7 +123443,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -123455,11 +123455,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -123511,11 +123511,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -123524,14 +123524,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 40 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 40 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -123549,10 +123549,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v9 int64 var r1 Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4, v5, v6, v7, v8 Tsyscall_arg_t var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v3, v4, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -123562,7 +123562,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 msg = bp } - v2 = int32(SYS_recvmsg) + v1 = int32(SYS_recvmsg) _ = int32(__SC_recvmsg) v3 = int64(fd) v4 = int64(msg) @@ -123571,9 +123571,9 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v7 = int64(Int32FromInt32(0)) v8 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = ___syscall_cp(tls, int64(v1), v3, v4, v5, v6, v7, v8) } else { - r = X__syscall6(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = X__syscall6(tls, int64(v1), v3, v4, v5, v6, v7, v8) } if r != int64(-Int32FromInt32(ENOSYS)) { v9 = r @@ -123614,7 +123614,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -123642,7 +123642,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -123785,7 +123785,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -123853,9 +123853,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -123875,7 +123875,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -123896,7 +123896,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -123966,7 +123966,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -123980,7 +123980,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -124014,7 +124014,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124041,7 +124041,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124069,7 +124069,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124091,13 +124091,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124136,7 +124136,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124150,7 +124150,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124167,10 +124167,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124188,7 +124188,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124247,7 +124247,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124299,7 +124299,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124322,7 +124322,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124352,9 +124352,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124369,11 +124369,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -124403,16 +124403,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]uint8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -124449,7 +124449,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1174) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -124462,103 +124462,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1181) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1191) if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1200, uint64(10)) != 0); v11 { - v8 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1200, uint64(10)) != 0); v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1211, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1218, uint64(6)) != 0; !v24 { - v21 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1211, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1218, uint64(6)) != 0; !v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -124618,7 +124618,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -124639,13 +124639,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1120) defer tls.Free(1120) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v12 int64 - var v1, v5 int32 + var v1 int32 var v10, v11, v6, v7, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+56 */ [66]Tcmsghdr var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -124674,15 +124674,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) + v1 = int32(SYS_sendmsg) _ = int32(__SC_sendmsg) v6 = int64(fd) v7 = int64(msg) @@ -124691,9 +124691,9 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v10 = int64(Int32FromInt32(0)) v11 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = ___syscall_cp(tls, int64(v1), v6, v7, v8, v9, v10, v11) } else { - r = X__syscall6(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = X__syscall6(tls, int64(v1), v6, v7, v8, v9, v10, v11) } if r != int64(-Int32FromInt32(ENOSYS)) { v12 = r @@ -124764,14 +124764,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, v18, v27, v8 int64 - var r1, v1, v11, v20 int32 + var r, v8 int64 + var r1, v1 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v10 uint64 - var v12, v13, v14, v15, v16, v17, v2, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8 + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) v2 = int64(fd) @@ -124827,27 +124827,27 @@ _9: 0: s, 1: int64(Int32FromUint64(v10)), } - v11 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v12 = int64(fd) - v13 = int64(level) - v14 = int64(optname) - v15 = int64(bp) - v16 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v17 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp) + v6 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v18 = r + v8 = r goto _19 } - v18 = r + v8 = r goto _19 _19: - r1 = int32(v18) + r1 = int32(v8) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -124860,27 +124860,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v20 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v21 = int64(fd) - v22 = int64(level) - v23 = int64(optname) - v24 = int64(optval) - v25 = Int64FromUint32(optlen) - v26 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = Int64FromUint32(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v27 = r + v8 = r goto _28 } - v27 = r + v8 = r goto _28 _28: - r1 = int32(v27) + r1 = int32(v8) break } } @@ -125160,18 +125160,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125186,14 +125186,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]uint8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125215,11 +125215,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -125259,11 +125259,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -125277,12 +125277,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -125295,11 +125295,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -125324,14 +125324,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -125393,9 +125393,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -125408,7 +125408,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -125525,7 +125525,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -125537,13 +125537,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -125564,32 +125564,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -125601,12 +125601,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -125626,21 +125626,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -125663,8 +125663,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -125677,7 +125677,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -125721,7 +125721,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -125749,7 +125749,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -125760,17 +125760,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -125785,18 +125785,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -125819,18 +125819,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125845,11 +125845,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]uint8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -125871,11 +125871,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]uint8)(unsafe.Pointer(bp + 44)) = [11]uint8{} @@ -125927,11 +125927,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126095,7 +126095,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126109,10 +126109,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126133,57 +126133,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v10)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v14)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126251,10 +126251,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -126340,7 +126340,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -126355,15 +126355,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -126766,7 +126766,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -126838,8 +126838,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -126849,14 +126849,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -126912,7 +126912,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -126928,7 +126928,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -126956,7 +126956,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -126972,7 +126972,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127000,7 +127000,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127016,7 +127016,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127046,11 +127046,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1361) seen_eacces = 0 @@ -127077,7 +127077,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } @@ -127097,9 +127097,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -127582,7 +127582,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -127590,12 +127590,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -127604,12 +127604,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -127618,7 +127618,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -127671,22 +127671,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = uint32(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -127704,15 +127704,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -127730,7 +127730,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(k) || *(*Twchar_t)(unsafe.Pointer(bp)) == Uint32FromInt32(kfold) { return BoolInt32(!(inv != 0)) @@ -127738,7 +127738,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -127746,13 +127746,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { @@ -127766,26 +127766,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127795,8 +127795,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -127821,13 +127821,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127847,18 +127847,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v10)))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127866,7 +127866,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -127876,22 +127876,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127913,7 +127913,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -127925,11 +127925,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -127939,7 +127939,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -127950,9 +127950,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -127960,7 +127960,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -127988,7 +127988,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128000,7 +128000,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128032,7 +128032,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128087,13 +128087,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(128) defer tls.Free(128) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep uint8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128105,9 +128105,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128124,8 +128124,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128145,7 +128145,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128154,9 +128154,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -128165,9 +128165,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128181,7 +128181,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { @@ -128216,19 +128216,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = uint8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 558 + v2 = __ccgo_ts + 558 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128238,9 +128238,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -128278,11 +128278,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*uint8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -128328,13 +128328,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 uint8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 uint8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -128342,16 +128342,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*uint8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1395) + v2 = Xgetenv(tls, __ccgo_ts+1395) } - home = v3 + home = v2 if !(home != 0) { if *(*uint8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -128386,20 +128386,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) } if *(*uint8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v13))) = uint8(0) + v1 = delim + *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -128473,7 +128473,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -128481,7 +128481,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -128495,7 +128495,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -128511,7 +128511,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -128525,7 +128525,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -128550,7 +128550,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -128946,7 +128946,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -128987,7 +128987,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -128997,7 +128997,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129095,7 +129095,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129133,16 +129133,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129155,8 +129155,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129167,16 +129167,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129187,11 +129187,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129240,11 +129240,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]uint8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -129269,7 +129269,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('[') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*uint8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -129284,21 +129284,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) - max = v4 - min = v4 - s += uintptr(len1) + v2 = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) + max = v2 + min = v2 + s = s + uintptr(len1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))) /* XXX - Should use collation order instead of @@ -129306,7 +129306,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -129314,9 +129314,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129349,11 +129349,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -129366,7 +129366,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -129425,11 +129425,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -129448,13 +129448,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -129467,7 +129467,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -129494,12 +129494,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -129513,7 +129513,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -129536,7 +129536,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -129562,11 +129562,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('['): @@ -129608,7 +129608,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { case 0: @@ -129622,12 +129622,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -129642,20 +129642,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -129671,7 +129671,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -129680,47 +129680,47 @@ _2: if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -129729,7 +129729,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -129738,7 +129738,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -129782,8 +129782,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(bp))), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -129801,12 +129801,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -129815,7 +129815,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -129823,28 +129823,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -129883,7 +129883,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -129907,7 +129907,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -129928,24 +129928,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130086,7 +130086,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130146,7 +130146,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130187,7 +130187,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130200,7 +130200,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130218,7 +130218,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130231,7 +130231,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130250,7 +130250,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -130285,13 +130285,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -130299,8 +130299,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -130335,7 +130335,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -130405,20 +130405,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -130502,26 +130502,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -130535,7 +130535,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -130629,7 +130629,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -130651,13 +130651,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -130712,8 +130712,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -130952,7 +130952,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -130993,7 +130993,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131036,7 +131036,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131053,8 +131053,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131117,7 +131117,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131127,7 +131127,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131137,7 +131137,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131166,7 +131166,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131181,7 +131181,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131192,7 +131192,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -131200,7 +131200,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131226,7 +131226,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131241,7 +131241,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -131249,7 +131249,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -131263,9 +131263,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -131294,7 +131294,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -131302,13 +131302,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -131609,9 +131609,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -131665,7 +131665,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -131680,7 +131680,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -131690,13 +131690,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -131714,7 +131714,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -131735,14 +131735,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -131757,7 +131757,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -131940,7 +131940,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -131985,7 +131985,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -131995,12 +131995,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -132022,7 +132022,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132053,7 +132053,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132065,7 +132065,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132128,7 +132128,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132161,7 +132161,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132202,11 +132202,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132249,7 +132249,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -132301,13 +132301,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) @@ -132360,44 +132360,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -132408,10 +132408,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -132419,10 +132419,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -132445,7 +132445,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -132468,7 +132468,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -132489,18 +132489,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -132535,7 +132535,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -132584,7 +132584,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -132615,7 +132615,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -132639,7 +132639,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -132720,13 +132720,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = uint32(0) *(*Ttre_char_t)(unsafe.Pointer(bp)) = uint32(0) @@ -132790,7 +132790,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -132801,12 +132801,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -132814,10 +132814,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = Int32FromUint32(*(*Ttre_char_t)(unsafe.Pointer(bp))) str_byte_start = str_byte @@ -132887,7 +132887,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -132937,7 +132937,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -132968,21 +132968,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -132993,18 +132993,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133075,7 +133075,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133103,9 +133103,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133132,7 +133132,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133188,8 +133188,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133212,7 +133212,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133228,23 +133228,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -133399,7 +133399,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -133470,7 +133470,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -133493,7 +133493,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -133521,8 +133521,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -133565,8 +133565,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -133622,11 +133622,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -133705,7 +133705,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -133737,7 +133737,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -133758,9 +133758,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -133769,11 +133769,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -133782,9 +133782,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -133793,14 +133793,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -133810,13 +133810,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -133957,17 +133957,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -133977,9 +133977,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -133994,15 +133994,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134162,8 +134162,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -134397,7 +134397,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) bp := tls.Alloc(80) defer tls.Free(80) var old, r, r1, v, v12, v15, v19, v22, v4, v7 int32 - var v1, v10, v11, v18, v25, v26, v27, v3 uintptr + var v1, v10, v11, v18, v3 uintptr var v2 int64 var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+48 */ Tk_sigaction @@ -134405,7 +134405,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v10, v11, v12, v15, v18, v19, v2, v22, v25, v26, v27, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v10, v11, v12, v15, v18, v19, v2, v22, v3, v4, v7 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -134525,24 +134525,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(SA_RESTORER) if (*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags&int32(SA_SIGINFO) != 0 { - v25 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v25 = __ccgo_fp(X__restore) + v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v25 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v26 = bp + 16 + v1 = bp + 16 } else { - v26 = uintptr(0) + v1 = uintptr(0) } if old1 != 0 { - v27 = bp + 48 + v3 = bp + 48 } else { - v27 = uintptr(0) + v3 = uintptr(0) } - r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v26), int64(v27), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) @@ -134644,7 +134644,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -134720,7 +134720,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -134759,7 +134759,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135095,7 +135095,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -135256,7 +135256,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -135534,19 +135534,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -135591,7 +135591,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -135700,13 +135700,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -135728,12 +135728,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -135757,11 +135757,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -135770,11 +135770,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -135804,9 +135804,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -135820,9 +135820,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -135843,8 +135843,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -135855,9 +135855,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136026,8 +136026,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136036,9 +136036,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -136109,7 +136109,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136222,16 +136222,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -136245,7 +136245,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136259,11 +136259,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136284,9 +136284,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -136302,9 +136302,9 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v13, v16, v18, v2, v21, v22, v5, v7, v9 int32 - var v1, v10, v11, v12, v20 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v18, v2, v20, v21, v22, v5, v7, v9 + var c, old, old1, r, v, v13, v16, v2, v5, v7, v9 int32 + var v1, v10, v11, v12 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -136338,49 +136338,49 @@ _8: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v10 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v10)) + *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v9 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v9 - v12 = f + 140 + c = v2 + v11 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1508) - v16 = v + v7 = v goto _17 _17: - old1 = v16 + old1 = v7 goto _15 _15: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1508) - v13 = BoolInt32(!(r != 0)) + v5 = BoolInt32(!(r != 0)) goto _14 _14: ; - if !!(v13 != 0) { + if !!(v5 != 0) { break } } - v18 = old1 + v9 = old1 goto _19 _19: - if v18&int32(MAYBE_WAITERS) != 0 { - v20 = f + 140 - v21 = int32(1) - v22 = int32(1) - if v22 != 0 { - v22 = int32(FUTEX_PRIVATE) + if v9&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v13 = int32(1) + v16 = int32(1) + if v16 != 0 { + v16 = int32(FUTEX_PRIVATE) } - if v21 < Int32FromInt32(0) { - v21 = int32(INT_MAX) + if v13 < Int32FromInt32(0) { + v13 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)|v22), int64(v21)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)), int64(v21)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 } return c } @@ -136399,7 +136399,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -136422,9 +136422,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136435,21 +136435,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -136486,13 +136486,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136511,7 +136511,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*uint8)(unsafe.Pointer(s)) = uint8(0) return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -136529,8 +136529,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -136538,24 +136538,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = Uint8FromInt32(c) - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } @@ -136602,7 +136602,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -136692,22 +136692,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -136725,7 +136725,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = uint32(0) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -136735,11 +136735,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -136853,7 +136853,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137016,11 +137016,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -137034,8 +137034,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137047,10 +137047,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137062,9 +137062,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -137192,10 +137192,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v14, v17, v19, v2, v22, v23, v5, v7, v9 int32 - var v1, v11, v12, v13, v21 uintptr + var old, old1, r, v, v14, v2, v5, v7, v9 int32 + var v1, v11 uintptr var v10 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v14, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -137230,50 +137230,50 @@ _8: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v10 = Uint8FromInt32(c) - v12 = f + 40 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - *(*uint8)(unsafe.Pointer(v11)) = v10 - v9 = Int32FromUint8(v10) + v11 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v10 + v2 = Int32FromUint8(v10) } else { - v9 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v9 - v13 = f + 140 + c = v2 + v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1521) - v17 = v + v5 = v goto _18 _18: - old1 = v17 + old1 = v5 goto _16 _16: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1521) - v14 = BoolInt32(!(r != 0)) + v2 = BoolInt32(!(r != 0)) goto _15 _15: ; - if !!(v14 != 0) { + if !!(v2 != 0) { break } } - v19 = old1 + v7 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v7&int32(MAYBE_WAITERS) != 0 { + v11 = f + 140 + v9 = int32(1) + v14 = int32(1) + if v14 != 0 { + v14 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -137295,7 +137295,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -137353,7 +137353,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = uint8(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -137483,8 +137483,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -137508,8 +137508,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -137517,11 +137517,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137531,8 +137531,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137576,7 +137576,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -137643,8 +137643,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -137652,7 +137652,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -137672,9 +137672,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137751,10 +137751,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -137861,11 +137861,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var old, owner, r, tid, v, v1, v3, v6, v8 int32 + var old, owner, r, tid, v, v1, v3, v6 int32 var self Tpthread_t var v10 bool var v2 uintptr - _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v10, v2, v3, v6, v8 + _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v10, v2, v3, v6 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -137873,7 +137873,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -137886,10 +137886,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1560) - v6 = v + v3 = v goto _7 _7: - old = v6 + old = v3 if old != 0 { // __asm__ __volatile__ ("dmb ish" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 20, __ccgo_ts+1560) @@ -137900,19 +137900,19 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1560) - v3 = BoolInt32(!(r != 0)) + v1 = BoolInt32(!(r != 0)) goto _4 _4: ; - if !!(v3 != 0) { + if !!(v1 != 0) { break } } - v8 = old + v6 = old goto _9 _9: } - if v10 || v8 != 0 { + if v10 || v6 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -137928,7 +137928,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -137937,9 +137937,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137962,11 +137962,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138014,15 +138014,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138092,9 +138092,9 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v13, v16, v18, v2, v21, v22, v5, v7, v9 int32 - var v1, v10, v11, v12, v20 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v18, v2, v20, v21, v22, v5, v7, v9 + var c, old, old1, r, v, v13, v16, v2, v5, v7, v9 int32 + var v1, v10, v11, v12 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -138128,49 +138128,49 @@ _8: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v10 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v10)) + *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v9 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v9 - v12 = f + 140 + c = v2 + v11 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1508) - v16 = v + v7 = v goto _17 _17: - old1 = v16 + old1 = v7 goto _15 _15: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1508) - v13 = BoolInt32(!(r != 0)) + v5 = BoolInt32(!(r != 0)) goto _14 _14: ; - if !!(v13 != 0) { + if !!(v5 != 0) { break } } - v18 = old1 + v9 = old1 goto _19 _19: - if v18&int32(MAYBE_WAITERS) != 0 { - v20 = f + 140 - v21 = int32(1) - v22 = int32(1) - if v22 != 0 { - v22 = int32(FUTEX_PRIVATE) + if v9&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v13 = int32(1) + v16 = int32(1) + if v16 != 0 { + v16 = int32(FUTEX_PRIVATE) } - if v21 < Int32FromInt32(0) { - v21 = int32(INT_MAX) + if v13 < Int32FromInt32(0) { + v13 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)|v22), int64(v21)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)), int64(v21)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 } return c } @@ -138189,7 +138189,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138222,7 +138222,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -138247,9 +138247,9 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v13, v16, v18, v2, v21, v22, v5, v7, v9 int32 - var v1, v10, v11, v12, v20 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v18, v2, v20, v21, v22, v5, v7, v9 + var c, old, old1, r, v, v13, v16, v2, v5, v7, v9 int32 + var v1, v10, v11, v12 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v16, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -138283,49 +138283,49 @@ _8: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v10 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v10)) + *(*uintptr)(unsafe.Pointer(v10)) = *(*uintptr)(unsafe.Pointer(v10)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v9 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v9 - v12 = f + 140 + c = v2 + v11 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1508) - v16 = v + v7 = v goto _17 _17: - old1 = v16 + old1 = v7 goto _15 _15: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1508) - v13 = BoolInt32(!(r != 0)) + v5 = BoolInt32(!(r != 0)) goto _14 _14: ; - if !!(v13 != 0) { + if !!(v5 != 0) { break } } - v18 = old1 + v9 = old1 goto _19 _19: - if v18&int32(MAYBE_WAITERS) != 0 { - v20 = f + 140 - v21 = int32(1) - v22 = int32(1) - if v22 != 0 { - v22 = int32(FUTEX_PRIVATE) + if v9&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v13 = int32(1) + v16 = int32(1) + if v16 != 0 { + v16 = int32(FUTEX_PRIVATE) } - if v21 < Int32FromInt32(0) { - v21 = int32(INT_MAX) + if v13 < Int32FromInt32(0) { + v13 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)|v22), int64(v21)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v20), int64(Int32FromInt32(FUTEX_WAKE)), int64(v21)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 } return c } @@ -138344,7 +138344,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138369,7 +138369,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138382,12 +138382,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 uint8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138423,7 +138423,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -138450,7 +138450,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -138458,14 +138458,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138477,14 +138477,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break @@ -138536,7 +138536,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138547,7 +138547,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) } *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) @@ -138726,17 +138726,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138752,9 +138752,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*uint8)(unsafe.Pointer(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138870,17 +138870,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138896,9 +138896,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = uint32(0) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138989,10 +138989,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v14, v17, v19, v2, v22, v23, v5, v7, v9 int32 - var v1, v11, v12, v13, v21 uintptr + var old, old1, r, v, v14, v2, v5, v7, v9 int32 + var v1, v11 uintptr var v10 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v14, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -139027,50 +139027,50 @@ _8: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v10 = Uint8FromInt32(c) - v12 = f + 40 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - *(*uint8)(unsafe.Pointer(v11)) = v10 - v9 = Int32FromUint8(v10) + v11 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v10 + v2 = Int32FromUint8(v10) } else { - v9 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v9 - v13 = f + 140 + c = v2 + v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1521) - v17 = v + v5 = v goto _18 _18: - old1 = v17 + old1 = v5 goto _16 _16: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1521) - v14 = BoolInt32(!(r != 0)) + v2 = BoolInt32(!(r != 0)) goto _15 _15: ; - if !!(v14 != 0) { + if !!(v2 != 0) { break } } - v19 = old1 + v7 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v7&int32(MAYBE_WAITERS) != 0 { + v11 = f + 140 + v9 = int32(1) + v14 = int32(1) + if v14 != 0 { + v14 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -139092,7 +139092,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139128,7 +139128,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139154,10 +139154,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v14, v17, v19, v2, v22, v23, v5, v7, v9 int32 - var v1, v11, v12, v13, v21 uintptr + var old, old1, r, v, v14, v2, v5, v7, v9 int32 + var v1, v11 uintptr var v10 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v14, v2, v5, v7, v9 v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); @@ -139192,50 +139192,50 @@ _8: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v10 = Uint8FromInt32(c) - v12 = f + 40 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - *(*uint8)(unsafe.Pointer(v11)) = v10 - v9 = Int32FromUint8(v10) + v11 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v10 + v2 = Int32FromUint8(v10) } else { - v9 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v9 - v13 = f + 140 + c = v2 + v1 = f + 140 for { // __asm__ __volatile__ ("ldaxr %w0,%1" : "=r"(v) : "Q"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1521) - v17 = v + v5 = v goto _18 _18: - old1 = v17 + old1 = v5 goto _16 _16: ; // __asm__ __volatile__ ("stlxr %w0,%w2,%1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 13, __ccgo_ts+1521) - v14 = BoolInt32(!(r != 0)) + v2 = BoolInt32(!(r != 0)) goto _15 _15: ; - if !!(v14 != 0) { + if !!(v2 != 0) { break } } - v19 = old1 + v7 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v7&int32(MAYBE_WAITERS) != 0 { + v11 = f + 140 + v9 = int32(1) + v14 = int32(1) + if v14 != 0 { + v14 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v11), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -139257,7 +139257,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139285,7 +139285,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139315,7 +139315,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -139651,7 +139651,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139686,7 +139686,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139722,7 +139722,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139756,7 +139756,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -139773,12 +139773,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -139795,10 +139795,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, c, uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, c, uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139807,13 +139807,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140089,7 +140089,7 @@ func _pad3(tls *TLS, f uintptr, c uint8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -140103,13 +140103,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140121,45 +140121,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -140174,13 +140174,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]uint8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140189,7 +140189,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]uint8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1586 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -140202,21 +140202,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*uint8)(unsafe.Pointer(v10)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v11)) = Uint8FromInt32(v12) - estr-- - v13 = estr - *(*uint8)(unsafe.Pointer(v13)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*uint8)(unsafe.Pointer(v15)) = uint8('.') + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140328,46 +140328,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -140383,22 +140383,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -140417,21 +140417,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -140443,8 +140443,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -140454,10 +140454,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -140465,15 +140465,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -140485,23 +140485,23 @@ _4: } } if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -140512,8 +140512,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -140532,14 +140532,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -140553,8 +140553,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -140578,21 +140578,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -140605,31 +140605,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*uint8)(unsafe.Pointer(v43)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v44)) = Uint8FromInt32(v45) - estr-- - v46 = estr - *(*uint8)(unsafe.Pointer(v46)) = Uint8FromInt32(t) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140653,15 +140653,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*uint8)(unsafe.Pointer(v48)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*uint8)(unsafe.Pointer(v49)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140679,21 +140679,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*uint8)(unsafe.Pointer(v51)) = uint8('0') + s3 = s3 - 1 + v5 = s3 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, uint8('0'), p+int32(9), int32(9), 0) } else { @@ -140707,30 +140707,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*uint8)(unsafe.Pointer(v54)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*uint8)(unsafe.Pointer(v55)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+558, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -140742,11 +140742,11 @@ _4: } _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -140765,7 +140765,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -140773,19 +140773,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]uint8 var _ /* mb at bp+48 */ [4]uint8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -140798,7 +140798,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -140811,7 +140811,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -140821,8 +140821,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140837,10 +140837,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -140848,11 +140848,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -140864,7 +140864,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -140873,19 +140873,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -140898,16 +140898,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -140915,7 +140915,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140931,7 +140931,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -140970,11 +140970,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141050,14 +141050,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141083,10 +141083,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141101,7 +141101,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -141119,12 +141119,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*uint8)(unsafe.Pointer(v35)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141138,24 +141138,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1627 + v8 = __ccgo_ts + 1627 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141169,23 +141169,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -141198,28 +141198,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141284,7 +141284,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141293,7 +141293,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -141319,12 +141319,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -141363,11 +141363,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -141421,7 +141421,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -141435,17 +141435,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -141468,99 +141468,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -141571,33 +141571,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -141651,14 +141651,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -141676,85 +141676,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -141768,10 +141768,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -141779,11 +141779,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -141795,36 +141795,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -141837,16 +141837,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -141857,12 +141857,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -141881,23 +141881,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v73))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -141906,40 +141906,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v79))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141947,7 +141947,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -141970,26 +141970,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142004,15 +142004,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -142021,6 +142013,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142036,20 +142036,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142061,7 +142061,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142070,7 +142070,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142242,7 +142242,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142299,7 +142299,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -142307,7 +142307,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]uint8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -142320,7 +142320,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -142344,7 +142344,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142359,7 +142359,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == uint32('$') { l10n = uint32(1) argpos = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - uint32('0')) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -142370,7 +142370,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - uint32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-uint32(' ')) goto _4 _4: ; @@ -142382,7 +142382,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -142397,13 +142397,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -142412,16 +142412,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == uint32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-uint32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -142477,7 +142477,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = Int32FromUint32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4))) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -142519,11 +142519,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -142544,27 +142544,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1627 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -142579,13 +142579,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -142637,7 +142637,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142646,7 +142646,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -142738,7 +142738,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142781,7 +142781,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if Uint32FromInt32(c) == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -142802,14 +142802,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -142834,23 +142834,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142861,37 +142861,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if Uint32FromInt32(c) != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142900,7 +142900,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -142910,7 +142910,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(*(*Twchar_t)(unsafe.Pointer(p))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == uint32('$') { dest = _arg_n1(tls, ap, *(*Twchar_t)(unsafe.Pointer(p))-uint32('0')) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -142921,8 +142921,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = Int32FromUint32(Uint32FromInt32(int32(10)*width) + *(*Twchar_t)(unsafe.Pointer(p)) - uint32('0')) - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -142935,9 +142935,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case uint32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == uint32('h') { p += 4 @@ -143009,45 +143009,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143074,8 +143074,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == uint32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == uint32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143094,17 +143094,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143112,11 +143112,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -143131,27 +143131,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = Uint32FromInt32(c) + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = Uint32FromInt32(c) if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143161,17 +143161,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, Uint32FromInt32(c)) + l = Xwctomb(tls, v5, Uint32FromInt32(c)) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143180,16 +143180,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143247,23 +143247,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1670, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1688, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143271,7 +143271,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143283,7 +143283,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143292,7 +143292,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143373,8 +143373,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143388,11 +143388,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -143513,11 +143513,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -143535,9 +143535,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = uint32(0) @@ -143551,9 +143551,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -143598,9 +143598,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -143618,10 +143618,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -143740,9 +143740,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -143753,27 +143753,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -143795,19 +143795,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143837,19 +143837,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143874,11 +143874,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -143905,9 +143905,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]uint8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -143924,9 +143924,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144102,9 +144102,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144113,7 +144113,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -144124,7 +144124,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -144136,10 +144136,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144150,16 +144150,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144190,12 +144190,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144242,13 +144242,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -144264,17 +144264,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -144282,7 +144282,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -144313,9 +144313,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -144325,11 +144325,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144502,7 +144502,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144510,7 +144510,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144521,11 +144521,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144546,11 +144546,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144606,7 +144606,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144614,7 +144614,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144625,11 +144625,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144650,11 +144650,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144764,9 +144764,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -144782,9 +144782,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -144800,7 +144800,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -144808,19 +144808,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -144859,8 +144859,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -144873,7 +144873,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -144884,8 +144884,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -144912,9 +144912,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -144932,9 +144932,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -144942,14 +144942,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -144963,32 +144963,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -144999,22 +144999,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -145030,23 +145030,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -145062,18 +145062,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -145089,170 +145089,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145262,27 +145262,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145424,29 +145424,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145481,22 +145481,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145504,10 +145504,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -145520,12 +145520,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145555,7 +145555,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -145580,9 +145580,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145595,14 +145595,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } for { @@ -145613,42 +145613,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } } @@ -145675,7 +145675,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -145733,9 +145733,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -145766,8 +145766,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -145783,8 +145783,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -145814,8 +145814,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 uint8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 uint8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -145829,8 +145829,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -145851,16 +145851,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -145899,9 +145899,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -145914,9 +145914,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { goto tail @@ -145931,7 +145931,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145939,19 +145939,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145993,8 +145993,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146033,7 +146033,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146096,7 +146096,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -146117,7 +146117,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146151,8 +146151,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146173,10 +146173,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) @@ -146184,16 +146184,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -146202,7 +146202,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146284,12 +146284,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 uint8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 uint8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146305,9 +146305,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146320,7 +146320,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146329,19 +146329,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*uint8)(unsafe.Pointer(d)) = uint8(0) goto finish @@ -146380,7 +146380,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146400,7 +146400,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146416,7 +146416,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146427,9 +146427,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146455,21 +146455,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + v1 = d + d = d + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) return a } @@ -146484,7 +146484,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146495,9 +146495,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146553,7 +146553,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*uint8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146584,7 +146584,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { end = uintptr(0) @@ -146610,7 +146610,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -146621,12 +146621,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -146638,10 +146638,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*uint8)(unsafe.Pointer(c)) != 0) { @@ -146655,22 +146655,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -146679,18 +146679,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146822,29 +146822,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146881,7 +146881,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -146891,22 +146891,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146914,10 +146914,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -146930,12 +146930,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -146983,9 +146983,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -146993,17 +146993,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v1 = _p2 + _p2 = _p2 + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147017,9 +147017,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147027,18 +147027,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147081,7 +147081,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147097,7 +147097,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147126,12 +147126,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -147331,7 +147331,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147344,7 +147344,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(l))) - Xtowlower(tls, *(*Twchar_t)(unsafe.Pointer(r)))) } @@ -147362,21 +147362,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = uint32(0) + *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) return a } @@ -147394,7 +147394,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147420,7 +147420,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147452,7 +147452,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147507,10 +147507,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -147520,7 +147520,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147534,23 +147534,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147559,29 +147559,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147618,16 +147618,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -147635,10 +147635,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -147651,12 +147651,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -147692,9 +147692,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147702,18 +147702,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = uint32(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = uint32(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147742,7 +147742,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -147767,7 +147767,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147795,7 +147795,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147814,8 +147814,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -147823,7 +147823,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147831,9 +147831,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -147857,7 +147857,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147890,7 +147890,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147915,27 +147915,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1730, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147998,7 +147998,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148209,7 +148209,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148260,38 +148260,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148299,15 +148299,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(Int32FromUint8(_days_in_month[months]) <= remdays) { break } - remdays -= Int32FromUint8(_days_in_month[months]) + remdays = remdays - Int32FromUint8(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148353,19 +148353,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148402,7 +148402,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148412,20 +148412,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148444,21 +148444,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148469,7 +148469,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148481,10 +148481,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148498,7 +148498,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148524,13 +148524,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148540,13 +148540,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]uint8 var _ /* dummy_name at bp+308 */ [7]uint8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1737) @@ -148570,7 +148570,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148584,7 +148584,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -148609,7 +148609,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1740) != 0) { @@ -148631,7 +148631,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -148658,7 +148658,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -148675,16 +148675,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -148704,7 +148704,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -148739,11 +148739,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148781,10 +148781,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -148813,7 +148813,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -148864,25 +148864,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -148925,16 +148925,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -149007,7 +149007,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -149024,8 +149024,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149035,15 +149035,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149053,11 +149053,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149453,9 +149453,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -149483,9 +149483,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149496,7 +149496,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149505,7 +149505,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149529,10 +149529,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1662 width = int32(2) def_pad = int32('0') @@ -149586,14 +149586,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -149610,7 +149610,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -149641,11 +149641,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -149654,14 +149654,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -149685,11 +149685,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -149749,11 +149749,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1854, VaList(bp+8, val))) case int32('_'): @@ -149795,15 +149795,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]uint8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -149815,21 +149815,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -149846,7 +149846,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -149857,8 +149857,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -149867,8 +149867,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -149881,50 +149881,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v7))) = uint8('-') - width-- + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v10))) = uint8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v12))) = uint8('0') + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -149958,15 +149958,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -149990,21 +149990,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -150014,7 +150014,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150111,7 +150111,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150166,19 +150166,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*uint8)(unsafe.Pointer(s)) != 0; v48 { - v45 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150190,7 +150190,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150198,7 +150198,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150262,7 +150262,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150275,9 +150275,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150296,13 +150296,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150317,30 +150317,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150360,13 +150360,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -150565,7 +150565,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -150573,7 +150573,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -150585,7 +150585,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != uint32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -150631,40 +150631,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = uint32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = uint32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = uint32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = uint32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151058,7 +151058,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) @@ -151211,7 +151211,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_loong64.go b/vendor/modernc.org/libc/ccgo_linux_loong64.go index 73ee111..07dec0a 100644 --- a/vendor/modernc.org/libc/ccgo_linux_loong64.go +++ b/vendor/modernc.org/libc/ccgo_linux_loong64.go @@ -689,14 +689,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -705,8 +705,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -1037,18 +1037,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -1080,9 +1080,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -1132,9 +1132,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1178,18 +1178,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1197,18 +1197,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1267,8 +1267,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1289,42 +1289,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1338,11 +1338,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1352,17 +1352,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1373,11 +1373,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1390,17 +1390,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1413,11 +1413,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1429,8 +1429,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1446,92 +1446,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1564,14 +1564,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1585,32 +1585,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1629,11 +1629,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1648,12 +1648,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1665,32 +1665,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1709,11 +1709,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1980,18 +1980,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1999,18 +1999,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -2023,8 +2023,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2045,42 +2045,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -2094,11 +2094,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2107,17 +2107,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2128,11 +2128,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2147,17 +2147,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2170,11 +2170,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2186,8 +2186,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2203,92 +2203,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2332,13 +2332,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2353,29 +2353,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2406,8 +2406,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2415,22 +2415,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2452,13 +2452,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2473,29 +2473,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2503,21 +2503,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2531,18 +2531,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2565,18 +2565,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2584,18 +2584,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2606,15 +2606,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2657,15 +2657,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2708,11 +2708,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2722,15 +2722,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2755,50 +2755,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7435,13 +7435,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7497,14 +7497,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7519,14 +7519,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= X__libc.Fpage_size + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7535,7 +7535,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -8911,16 +8911,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8929,10 +8929,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8941,16 +8941,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8959,16 +8959,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8977,58 +8977,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9048,7 +9048,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9059,12 +9059,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9072,36 +9072,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9109,9 +9109,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9120,10 +9120,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9170,9 +9170,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9189,25 +9189,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9218,11 +9218,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9247,7 +9247,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9260,7 +9260,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if int32(*(*int8)(unsafe.Pointer(setting))) != int32('$') || int32(*(*int8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[int32(*(*int8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || int32(*(*int8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || int32(*(*int8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9277,13 +9277,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9296,7 +9296,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9321,7 +9321,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9329,7 +9329,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9348,9 +9348,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9359,7 +9359,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*int8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = Int8FromUint8(_BF_itoa64[Int32FromUint8(_BF_atoi64[int32(*(*int8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)]) @@ -11242,7 +11242,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11269,14 +11269,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11286,8 +11286,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11322,35 +11322,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11363,10 +11363,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11380,19 +11380,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11403,7 +11403,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11419,10 +11419,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11431,7 +11431,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11441,23 +11441,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11488,12 +11488,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11503,10 +11503,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11526,11 +11526,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11545,11 +11545,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11561,12 +11561,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11775,7 +11775,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11783,60 +11783,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11849,7 +11849,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -11893,7 +11893,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -11910,8 +11910,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -11922,8 +11922,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -11963,15 +11963,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b64[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12002,7 +12002,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12041,7 +12041,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12071,13 +12071,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v5)) = int8('$') i = uint32(0) for { @@ -12088,7 +12088,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -12288,7 +12288,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12298,7 +12298,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12326,7 +12326,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12343,7 +12343,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12391,7 +12391,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12408,8 +12408,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12420,8 +12420,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12433,15 +12433,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b641[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12465,7 +12465,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12508,7 +12508,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12541,7 +12541,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12568,7 +12568,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12582,7 +12582,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12596,7 +12596,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12626,11 +12626,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12640,7 +12640,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -12950,7 +12950,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12967,8 +12967,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -12979,8 +12979,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -12992,15 +12992,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = Int8FromUint8(_b642[u%uint32(64)]) - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13024,7 +13024,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -13052,7 +13052,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13077,7 +13077,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13110,7 +13110,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13137,7 +13137,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13151,7 +13151,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13165,7 +13165,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13195,11 +13195,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13209,7 +13209,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*int8)(unsafe.Pointer(p)) = 0 @@ -13357,9 +13357,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13371,18 +13371,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17504,8 +17504,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22222,7 +22222,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22261,10 +22261,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22330,15 +22330,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22349,15 +22349,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -24914,10 +24914,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -24952,16 +24952,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -25031,7 +25031,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25150,7 +25150,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25252,7 +25252,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25264,7 +25264,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25709,7 +25709,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25733,7 +25733,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25777,7 +25777,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(__NR3264_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -25956,15 +25956,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -25973,23 +25973,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -25999,18 +25999,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26018,58 +26018,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26094,7 +26094,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26104,32 +26104,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26145,7 +26145,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26154,15 +26154,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26173,14 +26173,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26190,7 +26190,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26198,11 +26198,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26234,12 +26234,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26264,19 +26264,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26289,24 +26289,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26367,7 +26367,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26378,11 +26378,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26394,29 +26394,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26429,40 +26429,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26489,11 +26489,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26507,7 +26507,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26523,26 +26523,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26554,15 +26554,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26586,41 +26586,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26632,15 +26632,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26650,10 +26650,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26667,13 +26667,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26685,11 +26685,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26701,10 +26701,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26723,7 +26723,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26739,16 +26739,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -26757,24 +26757,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -26782,12 +26782,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -26801,55 +26801,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -26857,26 +26857,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26884,19 +26884,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27170,11 +27170,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27185,7 +27185,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27203,42 +27203,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27257,7 +27257,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27271,18 +27271,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27290,18 +27290,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27315,18 +27315,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27449,7 +27449,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*int8)(unsafe.Pointer(buf + uintptr(i))) = int8('0') @@ -27464,21 +27464,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(i))) = 0 for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*int8)(unsafe.Pointer(buf + uintptr(v5))) = Int8FromUint32(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27521,7 +27521,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28246,7 +28246,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28453,7 +28453,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && int32(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = 0 } @@ -28946,7 +28946,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30111,7 +30111,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31017,8 +31017,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31038,10 +31038,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31130,10 +31130,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98066,7 +98066,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98074,8 +98074,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98099,16 +98099,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98175,23 +98175,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98232,10 +98232,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98253,10 +98253,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98266,7 +98266,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]int8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98454,11 +98454,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98471,7 +98471,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98480,27 +98480,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98526,11 +98526,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98589,8 +98589,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98603,7 +98603,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -98627,7 +98627,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -98652,13 +98652,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -98676,17 +98676,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98695,9 +98695,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -98714,18 +98714,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -98797,7 +98797,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -98815,17 +98815,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98916,7 +98916,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -98936,7 +98936,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -98954,7 +98954,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -98963,17 +98963,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -98985,24 +98985,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*int8)(unsafe.Pointer(v57)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*int8)(unsafe.Pointer(v60)) = Int8FromUint32(v62) + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99011,7 +99011,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99021,14 +99021,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*int8)(unsafe.Pointer(v63)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*int8)(unsafe.Pointer(v65)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99040,56 +99040,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*int8)(unsafe.Pointer(v67)) = int8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*int8)(unsafe.Pointer(v69)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*int8)(unsafe.Pointer(v71)) = int8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*int8)(unsafe.Pointer(v73)) = int8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*int8)(unsafe.Pointer(v75)) = int8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*int8)(unsafe.Pointer(v77)) = int8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*int8)(unsafe.Pointer(v79)) = int8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*int8)(unsafe.Pointer(v81)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*int8)(unsafe.Pointer(v83)) = int8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*int8)(unsafe.Pointer(v85)) = int8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*int8)(unsafe.Pointer(v87)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99100,38 +99100,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*int8)(unsafe.Pointer(v89)) = int8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*int8)(unsafe.Pointer(v91)) = int8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*int8)(unsafe.Pointer(v93)) = int8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*int8)(unsafe.Pointer(v95)) = Int8FromUint32(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*int8)(unsafe.Pointer(v97)) = Int8FromUint32(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*int8)(unsafe.Pointer(v99)) = int8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*int8)(unsafe.Pointer(v101)) = int8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*int8)(unsafe.Pointer(v103)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = Int8FromUint32(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*int8)(unsafe.Pointer(v54)) = int8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99162,7 +99162,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99239,8 +99239,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99254,11 +99254,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 522 + v1 = __ccgo_ts + 522 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99295,13 +99295,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*int8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99370,11 +99370,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]int8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*int8)(unsafe.Pointer(val)) != 0) { @@ -99403,7 +99403,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if int32(*(*int8)(unsafe.Pointer(val))) == int32('.') || *(*int8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 531 @@ -99471,11 +99471,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99579,7 +99579,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99607,7 +99607,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -99684,7 +99684,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -99695,7 +99695,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99805,7 +99805,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -99819,7 +99819,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -99863,7 +99863,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99919,10 +99919,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]int8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -99958,7 +99958,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -99971,7 +99971,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -99982,22 +99982,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*int8)(unsafe.Pointer(s + uintptr(l))) = int8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = 0 + s = s - 1 + v3 = s + *(*int8)(unsafe.Pointer(v3)) = 0 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100010,11 +100010,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 522 + v3 = __ccgo_ts + 522 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100048,9 +100048,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100064,15 +100064,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v5)) = *(*int8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100084,9 +100084,9 @@ _4: for { switch int32(*(*int8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = int32(*(*int8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = int32(*(*int8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100107,7 +100107,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100118,13 +100118,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100133,12 +100133,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if int32(*(*int8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100147,12 +100147,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(int32(*(*int8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100163,8 +100163,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100359,9 +100359,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100374,11 +100374,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100578,12 +100578,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100603,11 +100603,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -100988,12 +100988,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101118,10 +101118,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101149,8 +101149,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101164,17 +101164,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101194,18 +101194,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101218,7 +101218,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101237,7 +101237,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101251,7 +101251,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101263,11 +101263,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101278,7 +101278,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101292,37 +101292,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101336,11 +101336,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101354,17 +101354,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101386,18 +101386,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101409,38 +101409,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101456,7 +101456,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101472,7 +101472,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101480,11 +101480,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101550,13 +101550,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -101713,12 +101713,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -101760,11 +101760,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102416,11 +102416,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102435,14 +102435,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102520,11 +102520,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -102637,11 +102637,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -102777,11 +102777,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -102945,12 +102945,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -102988,8 +102988,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103240,7 +103240,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103249,7 +103249,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103266,10 +103266,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103389,12 +103389,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103430,11 +103430,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -103708,7 +103708,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -103743,12 +103743,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -103775,11 +103775,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -103893,7 +103893,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -103928,12 +103928,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -103960,11 +103960,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104000,11 +104000,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104091,13 +104091,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104290,11 +104290,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104370,14 +104370,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104385,13 +104385,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104445,9 +104445,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104472,13 +104472,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104577,13 +104577,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -104718,7 +104718,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -104796,7 +104796,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -104853,7 +104853,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -104899,12 +104899,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -104913,8 +104913,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -104956,13 +104956,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -104971,10 +104971,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -104992,13 +104992,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105007,10 +105007,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105226,7 +105226,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105238,10 +105238,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105354,7 +105354,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) @@ -105364,24 +105364,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _3 @@ -105391,38 +105391,38 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>Int32FromInt32(32) != 0 { - y = uint32(v4 >> int32(32)) + v1 = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + if v1>>Int32FromInt32(32) != 0 { + y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) } else { - y = uint32(v4) + y = uint32(v1) r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } - v5 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) + v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _6 _6: - d = v5 - int32(1) + d = v2 - int32(1) if d < 0 { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105433,7 +105433,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { return float64(x1*y1) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105466,7 +105466,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) - r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) + r1 = r1 + float64(Tdouble_t(tiny*tiny)*(r1-r1)) } } else { /* only round once when scaled */ @@ -105499,13 +105499,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105514,27 +105514,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105542,11 +105542,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105556,13 +105556,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105571,27 +105571,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105599,11 +105599,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105621,13 +105621,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105636,27 +105636,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105664,11 +105664,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -105678,13 +105678,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105693,27 +105693,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -105721,11 +105721,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -105747,7 +105747,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -105760,7 +105760,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105808,13 +105808,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -105867,17 +105867,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106008,17 +106008,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106039,12 +106039,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106068,10 +106068,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106083,12 +106083,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106112,10 +106112,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106152,7 +106152,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106165,7 +106165,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106183,10 +106183,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106226,13 +106226,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106307,13 +106307,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106376,8 +106376,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106428,7 +106428,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106450,8 +106450,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106547,7 +106547,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -106703,7 +106703,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -106811,7 +106811,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -106891,7 +106891,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107036,7 +107036,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107144,7 +107144,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107235,7 +107235,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107382,7 +107382,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107489,7 +107489,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107571,7 +107571,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107713,7 +107713,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -107820,7 +107820,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -107860,7 +107860,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -107874,14 +107874,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -107924,7 +107924,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -107948,12 +107948,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -107966,8 +107966,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -107982,7 +107982,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108007,7 +108007,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108020,14 +108020,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108054,15 +108054,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108128,7 +108128,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108138,11 +108138,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108156,7 +108156,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108167,14 +108167,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108188,7 +108188,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108211,12 +108211,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108228,8 +108228,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108244,7 +108244,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108269,7 +108269,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108282,14 +108282,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108315,13 +108315,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108358,7 +108358,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108367,11 +108367,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108480,8 +108480,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108587,7 +108587,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108595,11 +108595,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108611,20 +108611,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -108738,7 +108738,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -108844,7 +108844,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -108852,11 +108852,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -108868,20 +108868,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109026,9 +109026,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109054,31 +109054,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109178,8 +109178,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109374,7 +109374,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109384,7 +109384,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109474,7 +109474,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109484,7 +109484,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -109533,9 +109533,9 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109558,31 +109558,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110201,9 +110201,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110301,9 +110301,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110360,8 +110360,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110375,7 +110375,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110404,32 +110404,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110559,12 +110559,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110651,16 +110651,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -110730,11 +110730,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, x2 Tdouble_t var ix, iy Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -110753,19 +110753,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -110779,14 +110779,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -110798,43 +110798,43 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111266,8 +111266,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111275,10 +111275,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111286,10 +111286,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111373,13 +111373,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111437,8 +111437,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111446,10 +111446,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111457,10 +111457,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111735,13 +111735,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -111757,10 +111757,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -111786,13 +111786,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -111808,10 +111808,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -111883,11 +111883,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -111896,11 +111896,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -111927,22 +111927,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -111988,12 +111988,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112008,18 +112008,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112051,14 +112051,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112074,18 +112074,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112098,9 +112098,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112146,13 +112146,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112168,18 +112168,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112210,11 +112210,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112230,24 +112230,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112308,13 +112308,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112328,18 +112328,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112370,11 +112370,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112544,9 +112544,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112565,7 +112565,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112574,7 +112574,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112602,9 +112602,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -112714,7 +112714,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -112749,9 +112749,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -112761,13 +112761,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -112793,11 +112793,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -112812,18 +112812,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112859,13 +112859,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112879,18 +112879,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112907,28 +112907,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113126,8 +113126,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113227,7 +113227,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113240,7 +113240,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113310,7 +113310,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113323,10 +113323,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113337,7 +113337,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113484,12 +113484,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*int8)(unsafe.Pointer(p)) = 0 return uintptr(unsafe.Pointer(&_s)) @@ -113540,7 +113540,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && int32(*(*int8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113549,7 +113549,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113583,7 +113583,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113595,7 +113595,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113607,7 +113607,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*int8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = 0 return s @@ -113701,7 +113701,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) == int32(*(*int8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*int8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -113716,11 +113716,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -113813,17 +113813,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114100,11 +114100,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if int32(*(*int8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114156,7 +114156,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114185,7 +114185,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114202,7 +114202,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114210,9 +114210,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(int32(*(*int8)(unsafe.Pointer(optstring + BoolUintptr(int32(*(*int8)(unsafe.Pointer(optstring))) == int32('+') || int32(*(*int8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114227,11 +114227,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if int32(*(*int8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') && int32(*(*int8)(unsafe.Pointer(opt))) == int32(*(*int8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*int8)(unsafe.Pointer(opt)) != 0 && int32(*(*int8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114242,11 +114242,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114263,22 +114263,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if int32(*(*int8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114304,7 +114304,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+710, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114320,13 +114320,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 779 + v5 = __ccgo_ts + 779 } else { - v6 = __ccgo_ts + 686 + v5 = __ccgo_ts + 686 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114440,7 +114440,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114465,7 +114465,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -114753,15 +114753,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -114771,12 +114771,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -114824,7 +114824,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -114967,28 +114967,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*int8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if int32(*(*int8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } if int32(*(*int8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*int8)(unsafe.Pointer(v3)) = *(*int8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -114998,29 +114998,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if int32(*(*int8)(unsafe.Pointer(val))) >= int32('0') && int32(*(*int8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (int32(*(*int8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*int8)(unsafe.Pointer(v7)) = Int8FromUint8(cval) + v1 = dest + dest = dest + 1 + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint8(cval) src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*int8)(unsafe.Pointer(v8)) = *(*int8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } } *(*int8)(unsafe.Pointer(dest)) = 0 @@ -115069,7 +115069,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+815, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115127,15 +115127,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(176) defer tls.Free(176) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+160 */ TFTW var _ /* new at bp+128 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115187,11 +115187,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel if h != 0 { @@ -115205,7 +115205,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && int32(*(*int8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115214,7 +115214,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) } @@ -115229,10 +115229,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115270,9 +115270,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*int8)(unsafe.Pointer(path + uintptr(j))) = int8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115284,11 +115284,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*int8)(unsafe.Pointer(path + uintptr(l))) = 0 - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115461,7 +115461,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for int32(*(*int8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115474,12 +115474,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]int8 var _ /* stack at bp+0 */ [4097]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115514,27 +115514,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') - p++ + p = p + 1 /* Initial // is special. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v5] = int8('/') + v4 = q + q = q + 1 + (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[v4] = int8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115544,17 +115544,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]int8)(unsafe.Pointer(bp)))[v7] = int8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q+l] = 0 - p += l + p = p + l up = 0 if l0 == uint64(2) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115563,8 +115563,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115593,23 +115593,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || int32((*(*[4096]int8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115617,10 +115617,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if int32((*(*[4097]int8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for int32((*(*[4097]int8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115628,7 +115628,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115642,26 +115642,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && int32((*(*[4097]int8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]int8)(unsafe.Pointer(bp)))[v11] = int8('/') + v4 = l + l = l + 1 + (*(*[4097]int8)(unsafe.Pointer(bp)))[v4] = int8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116145,19 +116145,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]int8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]int8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116175,12 +116175,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if int32((*(*[1024]int8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v2] = int8('\n') + v1 = l + l = l + 1 + (*(*[1024]int8)(unsafe.Pointer(bp + 80)))[v1] = int8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+639, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116433,7 +116433,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for int32(*(*int8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -116678,11 +116678,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -116721,9 +116721,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -116732,10 +116732,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -116897,12 +116897,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + wn = wn - 1 goto _4 _4: } @@ -116917,44 +116917,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -116974,76 +116974,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117192,31 +117192,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xc0) | wc>>Int32FromInt32(6)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*int8)(unsafe.Pointer(v7)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*int8)(unsafe.Pointer(s)) = int8(int32(0x80) | wc&int32(0x3f)) return uint64(4) } @@ -117262,16 +117262,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117287,9 +117287,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]int8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117303,9 +117303,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117325,13 +117325,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117350,13 +117350,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118471,9 +118471,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118484,8 +118484,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118497,20 +118497,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -118523,34 +118523,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -118564,17 +118564,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -118625,22 +118625,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -118662,9 +118662,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -118700,26 +118700,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*int8)(unsafe.Pointer(v3)) = int8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*int8)(unsafe.Pointer(v6)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v3)) = Int8FromUint8(*(*uint8)(unsafe.Pointer(v4))) } } else { *(*int8)(unsafe.Pointer(dest)) = 0 @@ -118732,7 +118732,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -118767,7 +118767,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -118877,9 +118877,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -118891,31 +118891,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -118923,7 +118923,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119265,7 +119265,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if int32(*(*int8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119277,7 +119277,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if int32(*(*int8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119317,11 +119317,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 966 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119364,9 +119364,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119375,15 +119375,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119400,7 +119400,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -119412,16 +119412,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -119524,7 +119524,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -119594,13 +119594,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -119731,7 +119731,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119796,15 +119796,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -119854,7 +119854,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119913,41 +119913,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120209,7 +120209,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120390,17 +120390,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120413,29 +120413,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*int8)(unsafe.Pointer(v3)) = int8('.') - v4 = s - s++ - *(*int8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*int8)(unsafe.Pointer(v5)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = int8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+997) } @@ -120445,15 +120445,15 @@ var _xdigits = [17]int8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', ' func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1006, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120468,7 +120468,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -120486,14 +120486,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120506,35 +120506,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*int8)(unsafe.Pointer(p)) != 0; v13 { - v10 = int32(*(*int8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(p)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*int8)(unsafe.Pointer(z)) != 0; v18 { - v15 = int32(*(*int8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*int8)(unsafe.Pointer(z)) != 0; v7 { + v4 = int32(*(*int8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if int64(z)-int64(p) < int64(256) { @@ -120548,7 +120548,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -120556,7 +120556,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]int8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1030, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -120566,7 +120566,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } @@ -120584,14 +120584,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*int8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -120691,7 +120691,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = int8('%') Xstrcat(tls, bp+78, p) @@ -120796,7 +120796,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -120875,12 +120875,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(32) defer tls.Free(32) - var r, v17, v26, v8 int64 - var r1, v1, v10, v19 int32 + var r, v8 int64 + var r1, v1 int32 var tv uintptr - var v11, v12, v13, v14, v15, v16, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7 Tsyscall_arg_t + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t var _ /* tv32 at bp+8 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) v2 = int64(fd) @@ -120924,27 +120924,27 @@ _9: *(*[1]Tsocklen_t)(unsafe.Pointer(bp)) = [1]Tsocklen_t{ 0: uint32(16), } - v10 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v11 = int64(fd) - v12 = int64(level) - v13 = int64(optname) - v14 = int64(bp + 8) - v15 = int64(bp) - v16 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp + 8) + v6 = int64(bp) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v17 = r + v8 = r goto _18 } - v17 = r + v8 = r goto _18 _18: - r1 = int32(v17) + r1 = int32(v8) if r1 < 0 { break } @@ -120964,27 +120964,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v19 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v20 = int64(fd) - v21 = int64(level) - v22 = int64(optname) - v23 = int64(optval) - v24 = int64(optlen) - v25 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = int64(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v26 = r + v8 = r goto _27 } - v26 = r + v8 = r goto _27 _27: - r1 = int32(v26) + r1 = int32(v8) break } } @@ -121034,7 +121034,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*int8)(unsafe.Pointer(s)) != 0) { break @@ -121046,16 +121046,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121226,7 +121226,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121272,14 +121272,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = 0 goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121301,9 +121301,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121313,11 +121313,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121365,7 +121365,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121395,7 +121395,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -121422,12 +121422,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Int8FromUint8(':') @@ -121554,7 +121554,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -121568,11 +121568,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -121593,7 +121593,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && int32(*(*int8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -121605,11 +121605,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -121619,7 +121619,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = int32(*(*int8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && int32(*(*int8)(unsafe.Pointer(v4))) != int32(':') { @@ -121630,9 +121630,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if int32(*(*int8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*int8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*int8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -121640,22 +121640,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -121672,15 +121672,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -121693,7 +121693,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -121701,16 +121701,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -121789,7 +121789,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -121839,14 +121839,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -121854,23 +121854,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -121879,9 +121879,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -121899,14 +121899,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -121929,15 +121929,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*int8)(unsafe.Pointer(v2)) = int8('\n') *(*int8)(unsafe.Pointer(p)) = Int8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -121956,7 +121956,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -121964,26 +121964,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*int8)(unsafe.Pointer(p)) != 0; v17 { - v14 = int32(*(*int8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*int8)(unsafe.Pointer(v18)) = 0 + v1 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -121995,35 +121995,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*int8)(unsafe.Pointer(p)) != 0; v23 { - v20 = int32(*(*int8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(p)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*int8)(unsafe.Pointer(z)) != 0; v28 { - v25 = int32(*(*int8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*int8)(unsafe.Pointer(z)) != 0; v11 { + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*int8)(unsafe.Pointer(z)) = 0 if _is_valid_hostname(tls, p) != 0 { @@ -122033,11 +122033,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122084,7 +122084,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122129,14 +122129,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122158,7 +122158,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122173,7 +122173,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122198,13 +122198,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]int8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122218,19 +122218,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if int32(*(*int8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*int8)(unsafe.Pointer(bp)) = 0 } /* Strip final dot for canon, fail if multiple trailing dots. */ if int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || int32(*(*int8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122261,23 +122261,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*int8)(unsafe.Pointer(z)) != 0; v12 { - v9 = int32(*(*int8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = int32(*(*int8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122363,7 +122363,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -122399,7 +122399,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -122419,7 +122419,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -122429,7 +122429,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*int8)(unsafe.Pointer(canon)) = 0 if name != 0 { @@ -122447,7 +122447,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -122481,7 +122481,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -122490,18 +122490,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -122519,7 +122519,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -122538,7 +122538,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -122592,31 +122592,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122763,19 +122763,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*int8)(unsafe.Pointer(p)) != 0; v19 { - v16 = int32(*(*int8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*int8)(unsafe.Pointer(p)) != 0; v10 { + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -122787,9 +122787,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1049, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -122797,18 +122797,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -122971,34 +122971,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123013,21 +123013,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123040,14 +123040,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123074,7 +123074,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123085,18 +123085,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123113,8 +123113,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123149,22 +123149,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123175,7 +123175,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123298,7 +123298,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -123395,7 +123395,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -123407,11 +123407,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -123463,11 +123463,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -123476,14 +123476,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 40 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 40 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -123501,10 +123501,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v9 int64 var r1 Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4, v5, v6, v7, v8 Tsyscall_arg_t var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v3, v4, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -123514,7 +123514,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 msg = bp } - v2 = int32(SYS_recvmsg) + v1 = int32(SYS_recvmsg) _ = int32(__SC_recvmsg) v3 = int64(fd) v4 = int64(msg) @@ -123523,9 +123523,9 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v7 = int64(Int32FromInt32(0)) v8 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = ___syscall_cp(tls, int64(v1), v3, v4, v5, v6, v7, v8) } else { - r = X__syscall6(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = X__syscall6(tls, int64(v1), v3, v4, v5, v6, v7, v8) } if r != int64(-Int32FromInt32(ENOSYS)) { v9 = r @@ -123566,7 +123566,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && int32(*(*int8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -123594,7 +123594,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -123737,7 +123737,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -123805,9 +123805,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -123827,7 +123827,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -123848,7 +123848,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -123918,7 +123918,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -123932,7 +123932,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -123966,7 +123966,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -123993,7 +123993,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124021,7 +124021,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124043,13 +124043,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124088,7 +124088,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124102,7 +124102,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124119,10 +124119,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124140,7 +124140,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124199,7 +124199,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124251,7 +124251,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124274,7 +124274,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124304,9 +124304,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124321,11 +124321,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -124355,16 +124355,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]int8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -124401,7 +124401,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1164) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -124414,103 +124414,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1171) if p != 0 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1181) if p != 0 && (BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || int32(*(*int8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1190, uint64(10)) != 0); v11 { - v8 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1190, uint64(10)) != 0); v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = int32(*(*int8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = 0 if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1201, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1208, uint64(6)) != 0; !v24 { - v21 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1201, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1208, uint64(6)) != 0; !v4 { + v1 = int32((*(*[256]int8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = int32(*(*int8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = int32(*(*int8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -124570,7 +124570,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -124591,13 +124591,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1120) defer tls.Free(1120) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v12 int64 - var v1, v5 int32 + var v1 int32 var v10, v11, v6, v7, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+56 */ [66]Tcmsghdr var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -124626,15 +124626,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) + v1 = int32(SYS_sendmsg) _ = int32(__SC_sendmsg) v6 = int64(fd) v7 = int64(msg) @@ -124643,9 +124643,9 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v10 = int64(Int32FromInt32(0)) v11 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = ___syscall_cp(tls, int64(v1), v6, v7, v8, v9, v10, v11) } else { - r = X__syscall6(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = X__syscall6(tls, int64(v1), v6, v7, v8, v9, v10, v11) } if r != int64(-Int32FromInt32(ENOSYS)) { v12 = r @@ -124716,14 +124716,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, v18, v27, v8 int64 - var r1, v1, v11, v20 int32 + var r, v8 int64 + var r1, v1 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v10 uint64 - var v12, v13, v14, v15, v16, v17, v2, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8 + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) v2 = int64(fd) @@ -124779,27 +124779,27 @@ _9: 0: s, 1: int64(Int32FromUint64(v10)), } - v11 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v12 = int64(fd) - v13 = int64(level) - v14 = int64(optname) - v15 = int64(bp) - v16 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v17 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp) + v6 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v18 = r + v8 = r goto _19 } - v18 = r + v8 = r goto _19 _19: - r1 = int32(v18) + r1 = int32(v8) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -124812,27 +124812,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v20 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v21 = int64(fd) - v22 = int64(level) - v23 = int64(optname) - v24 = int64(optval) - v25 = Int64FromUint32(optlen) - v26 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = Int64FromUint32(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v27 = r + v8 = r goto _28 } - v27 = r + v8 = r goto _28 _28: - r1 = int32(v27) + r1 = int32(v8) break } } @@ -125112,18 +125112,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125138,14 +125138,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]int8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125167,11 +125167,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -125211,11 +125211,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -125229,12 +125229,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -125247,11 +125247,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -125276,14 +125276,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*int8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -125345,9 +125345,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -125360,7 +125360,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -125477,7 +125477,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -125489,13 +125489,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -125516,32 +125516,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -125553,12 +125553,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -125578,21 +125578,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -125615,8 +125615,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -125629,7 +125629,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -125673,7 +125673,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -125701,7 +125701,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -125712,17 +125712,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -125737,18 +125737,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -125771,18 +125771,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*int8)(unsafe.Pointer(v1)) = 0 for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*int8)(unsafe.Pointer(v2)) = Int8FromUint32(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*int8)(unsafe.Pointer(v1)) = Int8FromUint32(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125797,11 +125797,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]int8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -125823,11 +125823,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]int8)(unsafe.Pointer(bp + 44)) = [11]int8{} @@ -125879,11 +125879,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126047,7 +126047,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126061,10 +126061,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126085,57 +126085,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = 0 *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v6)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v8)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v9)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v10)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v12)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*int8)(unsafe.Pointer(v14)) = 0 + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*int8)(unsafe.Pointer(v4)) = 0 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126203,10 +126203,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -126292,7 +126292,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -126307,15 +126307,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -126718,7 +126718,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -126790,8 +126790,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -126801,14 +126801,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -126864,7 +126864,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -126880,7 +126880,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -126908,7 +126908,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -126924,7 +126924,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -126952,7 +126952,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -126968,7 +126968,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -126998,11 +126998,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1351) seen_eacces = 0 @@ -127029,7 +127029,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } @@ -127049,9 +127049,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*int8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*int8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -127534,7 +127534,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if int32(*(*int8)(unsafe.Pointer(pat))) == int32('\\') && *(*int8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -127542,12 +127542,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -127556,12 +127556,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = int32(*(*int8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (int32(*(*int8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || int32(*(*int8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -127570,7 +127570,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*int8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -127623,22 +127623,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if int32(*(*int8)(unsafe.Pointer(p))) == int32('^') || int32(*(*int8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if int32(*(*int8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -127656,15 +127656,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if int32(*(*int8)(unsafe.Pointer(p))) == int32('[') && (int32(*(*int8)(unsafe.Pointer(p + 1))) == int32(':') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('.') || int32(*(*int8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = int32(*(*int8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for int32(*(*int8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || int32(*(*int8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -127682,7 +127682,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -127690,7 +127690,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -127698,13 +127698,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if int32(*(*int8)(unsafe.Pointer(str))) == int32('.') && int32(*(*int8)(unsafe.Pointer(pat))) != int32('.') { @@ -127718,26 +127718,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127747,8 +127747,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -127773,13 +127773,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127799,18 +127799,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = Uint32FromInt8(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v10))))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(Uint8FromInt8(*(*int8)(unsafe.Pointer(v6))))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127818,7 +127818,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -127828,22 +127828,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127865,7 +127865,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -127877,11 +127877,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -127891,7 +127891,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -127902,9 +127902,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -127912,7 +127912,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -127940,7 +127940,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -127952,7 +127952,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != int32(*(*int8)(unsafe.Pointer(s))) && (!(*(*int8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -127984,7 +127984,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128039,13 +128039,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(128) defer tls.Free(128) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep int8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128057,9 +128057,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && int32(*(*int8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*int8)(unsafe.Pointer(buf + uintptr(v1))) = *(*int8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128076,8 +128076,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128097,7 +128097,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*int8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128106,9 +128106,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -128117,9 +128117,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*int8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128133,7 +128133,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*int8)(unsafe.Pointer(buf + uintptr(pos))) = 0 if !(*(*int8)(unsafe.Pointer(pat)) != 0) { @@ -128168,19 +128168,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = int8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 558 + v2 = __ccgo_ts + 558 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128190,9 +128190,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -128230,11 +128230,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*int8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -128280,13 +128280,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 int8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 int8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -128294,16 +128294,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*int8)(unsafe.Pointer(v2)) = 0 } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*int8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1385) + v2 = Xgetenv(tls, __ccgo_ts+1385) } - home = v3 + home = v2 if !(home != 0) { if *(*int8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -128338,20 +128338,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*int8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = *(*int8)(unsafe.Pointer(v2)) } if *(*int8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*int8)(unsafe.Pointer(buf + uintptr(v13))) = 0 + v1 = delim + *(*int8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*int8)(unsafe.Pointer(buf + uintptr(v10))) = 0 } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -128425,7 +128425,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -128433,7 +128433,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -128447,7 +128447,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -128463,7 +128463,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -128477,7 +128477,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -128502,7 +128502,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -128898,7 +128898,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -128939,7 +128939,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -128949,7 +128949,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129047,7 +129047,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129085,16 +129085,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129107,8 +129107,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129119,16 +129119,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129139,11 +129139,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129192,11 +129192,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]int8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -129221,7 +129221,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if int32(*(*int8)(unsafe.Pointer(s))) == int32('[') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*int8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -129236,21 +129236,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || int32(*(*int8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') && int32(*(*int8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -129258,7 +129258,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -129266,9 +129266,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129301,11 +129301,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -129318,7 +129318,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(int32(*(*int8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -129377,11 +129377,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -129400,13 +129400,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -129419,7 +129419,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (int32(*(*int8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -129446,12 +129446,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && int32(*(*int8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || int32(*(*int8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -129465,7 +129465,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -129488,7 +129488,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -129514,11 +129514,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('['): @@ -129560,7 +129560,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch int32(*(*int8)(unsafe.Pointer(v14))) { case 0: @@ -129574,12 +129574,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if int32(*(*int8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -129594,20 +129594,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if int32(*(*int8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -129623,7 +129623,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -129632,47 +129632,47 @@ _2: if !(ere != 0) && Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = int32(*(*int8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -129681,7 +129681,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -129690,7 +129690,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -129734,8 +129734,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -129753,12 +129753,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -129767,7 +129767,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -129775,28 +129775,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && int32(*(*int8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -129835,7 +129835,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if int32(*(*int8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && int32(*(*int8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -129859,7 +129859,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if int32(*(*int8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -129880,24 +129880,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && int32(*(*int8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130038,7 +130038,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130098,7 +130098,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130139,7 +130139,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130152,7 +130152,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130170,7 +130170,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130183,7 +130183,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130202,7 +130202,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -130237,13 +130237,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -130251,8 +130251,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -130287,7 +130287,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -130357,20 +130357,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -130454,26 +130454,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -130487,7 +130487,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -130581,7 +130581,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -130603,13 +130603,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -130664,8 +130664,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -130904,7 +130904,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -130945,7 +130945,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -130988,7 +130988,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131005,8 +131005,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131069,7 +131069,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131079,7 +131079,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131089,7 +131089,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131118,7 +131118,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131133,7 +131133,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131144,7 +131144,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -131152,7 +131152,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131178,7 +131178,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131193,7 +131193,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -131201,7 +131201,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -131215,9 +131215,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -131246,7 +131246,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -131254,13 +131254,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -131561,9 +131561,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -131617,7 +131617,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -131632,7 +131632,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -131642,13 +131642,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -131666,7 +131666,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -131687,14 +131687,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -131709,7 +131709,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -131892,7 +131892,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -131937,7 +131937,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -131947,12 +131947,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -131974,7 +131974,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132005,7 +132005,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132017,7 +132017,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132080,7 +132080,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132113,7 +132113,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132154,11 +132154,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*int8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132201,7 +132201,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -132253,13 +132253,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132312,44 +132312,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -132360,10 +132360,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -132371,10 +132371,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -132397,7 +132397,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -132420,7 +132420,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -132441,18 +132441,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -132487,7 +132487,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -132536,7 +132536,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -132567,7 +132567,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -132591,7 +132591,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -132672,13 +132672,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132742,7 +132742,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -132753,12 +132753,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -132766,10 +132766,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -132839,7 +132839,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -132889,7 +132889,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -132920,21 +132920,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -132945,18 +132945,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133027,7 +133027,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133055,9 +133055,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133084,7 +133084,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133140,8 +133140,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133164,7 +133164,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133180,23 +133180,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -133351,7 +133351,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -133422,7 +133422,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -133445,7 +133445,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -133473,8 +133473,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -133517,8 +133517,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -133574,11 +133574,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -133657,7 +133657,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -133689,7 +133689,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -133710,9 +133710,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -133721,11 +133721,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -133734,9 +133734,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -133745,14 +133745,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -133762,13 +133762,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -133909,17 +133909,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -133929,9 +133929,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -133946,15 +133946,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134114,8 +134114,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -134349,7 +134349,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) bp := tls.Alloc(80) defer tls.Free(80) var old, r, r1, v, v12, v15, v19, v22, v4, v7 int32 - var v1, v10, v11, v18, v25, v26, v3 uintptr + var v1, v10, v11, v18, v3 uintptr var v2 int64 var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+48 */ Tk_sigaction @@ -134357,7 +134357,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v10, v11, v12, v15, v18, v19, v2, v22, v25, v26, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v10, v11, v12, v15, v18, v19, v2, v22, v3, v4, v7 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -134514,16 +134514,16 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Xmemcpy(tls, bp+16+16, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v25 = bp + 16 + v1 = bp + 16 } else { - v25 = uintptr(0) + v1 = uintptr(0) } if old1 != 0 { - v26 = bp + 48 + v3 = bp + 48 } else { - v26 = uintptr(0) + v3 = uintptr(0) } - r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v25), int64(v26), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) @@ -134625,7 +134625,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -134701,7 +134701,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -134740,7 +134740,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135076,7 +135076,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -135160,7 +135160,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -135438,19 +135438,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if int32(*(*int8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if int32(*(*int8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -135495,7 +135495,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -135604,13 +135604,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -135632,12 +135632,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -135661,11 +135661,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -135674,11 +135674,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -135708,9 +135708,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -135724,9 +135724,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -135747,8 +135747,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -135759,9 +135759,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -135930,8 +135930,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -135940,9 +135940,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -136013,7 +136013,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136126,16 +136126,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -136149,7 +136149,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136163,11 +136163,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136188,9 +136188,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -136206,10 +136206,10 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v14, v17, v19, v2, v22, v23, v6, v8 int32 - var v1, v11, v12, v13, v21 uintptr + var c, old, old1, r, v, v10, v14, v17, v2, v6, v8 int32 + var v1, v11, v12, v13 uintptr var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) @@ -136251,15 +136251,15 @@ _9: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v11 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v10 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v10 - v13 = f + 140 + c = v2 + v12 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) for { @@ -136269,10 +136269,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1498) - v17 = v + v8 = v goto _18 _18: - old1 = v17 + old1 = v8 goto _16 _16: ; @@ -136282,30 +136282,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1498) - v14 = r + v6 = r goto _15 _15: ; - if !!(v14 != 0) { + if !!(v6 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) - v19 = old1 + v10 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v13 = f + 140 + v14 = int32(1) + v17 = int32(1) + if v17 != 0 { + v17 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v14 < Int32FromInt32(0) { + v14 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 } return c } @@ -136324,7 +136324,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -136347,9 +136347,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136360,21 +136360,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -136411,13 +136411,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136436,7 +136436,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*int8)(unsafe.Pointer(s)) = 0 return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -136454,8 +136454,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -136463,24 +136463,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = int8(c) - v9 = p - p++ - *(*int8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*int8)(unsafe.Pointer(v6)) = v8 if int32(v8) == int32('\n') { break } @@ -136527,7 +136527,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -136617,22 +136617,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -136650,7 +136650,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -136660,11 +136660,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -136778,7 +136778,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -136941,11 +136941,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -136959,8 +136959,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -136972,10 +136972,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -136987,9 +136987,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -137117,11 +137117,11 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v15, v18, v2, v20, v23, v24, v6, v8 int32 - var v1, v12, v13, v14, v22 uintptr + var old, old1, r, v, v10, v15, v2, v6, v8 int32 + var v1, v12 uintptr var v11 uint8 var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v15, v18, v2, v20, v22, v23, v24, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v15, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) @@ -137164,16 +137164,16 @@ _9: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v11 = Uint8FromInt32(c) - v13 = f + 40 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - *(*uint8)(unsafe.Pointer(v12)) = v11 - v10 = Int32FromUint8(v11) + v12 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v12)) + *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v11 + v2 = Int32FromUint8(v11) } else { - v10 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v10 - v14 = f + 140 + c = v2 + v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) for { @@ -137183,10 +137183,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1511) - v18 = v + v6 = v goto _19 _19: - old1 = v18 + old1 = v6 goto _17 _17: ; @@ -137196,30 +137196,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1511) - v15 = r + v2 = r goto _16 _16: ; - if !!(v15 != 0) { + if !!(v2 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) - v20 = old1 + v8 = old1 goto _21 _21: - if v20&int32(MAYBE_WAITERS) != 0 { - v22 = f + 140 - v23 = int32(1) - v24 = int32(1) - if v24 != 0 { - v24 = int32(FUTEX_PRIVATE) + if v8&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v10 = int32(1) + v15 = int32(1) + if v15 != 0 { + v15 = int32(FUTEX_PRIVATE) } - if v23 < Int32FromInt32(0) { - v23 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)|v24), int64(v23)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)), int64(v23)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -137241,7 +137241,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -137299,7 +137299,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -137429,8 +137429,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -137454,8 +137454,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -137463,11 +137463,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137477,8 +137477,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137522,7 +137522,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(__NR3264_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(__NR3264_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -137589,8 +137589,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -137598,7 +137598,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -137618,9 +137618,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137697,10 +137697,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -137807,11 +137807,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var old, owner, r, tid, v, v1, v3, v7, v9 int32 + var old, owner, r, tid, v, v1, v3, v7 int32 var self Tpthread_t var v11, v5 bool var v2 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v11, v2, v3, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v11, v2, v3, v5, v7 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -137819,7 +137819,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -137838,10 +137838,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1550) - v7 = v + v3 = v goto _8 _8: - old = v7 + old = v3 goto _6 _6: ; @@ -137852,21 +137852,21 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1550) - v3 = r + v1 = r goto _4 _4: } - if !(v5 && !(v3 != 0)) { + if !(v5 && !(v1 != 0)) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1550) - v9 = old + v7 = old goto _10 _10: } - if v11 || v9 != 0 { + if v11 || v7 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -137882,7 +137882,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -137891,9 +137891,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -137916,11 +137916,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -137968,15 +137968,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138046,10 +138046,10 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v14, v17, v19, v2, v22, v23, v6, v8 int32 - var v1, v11, v12, v13, v21 uintptr + var c, old, old1, r, v, v10, v14, v17, v2, v6, v8 int32 + var v1, v11, v12, v13 uintptr var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) @@ -138091,15 +138091,15 @@ _9: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v11 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v10 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v10 - v13 = f + 140 + c = v2 + v12 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) for { @@ -138109,10 +138109,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1498) - v17 = v + v8 = v goto _18 _18: - old1 = v17 + old1 = v8 goto _16 _16: ; @@ -138122,30 +138122,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1498) - v14 = r + v6 = r goto _15 _15: ; - if !!(v14 != 0) { + if !!(v6 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) - v19 = old1 + v10 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v13 = f + 140 + v14 = int32(1) + v17 = int32(1) + if v17 != 0 { + v17 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v14 < Int32FromInt32(0) { + v14 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 } return c } @@ -138164,7 +138164,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138197,7 +138197,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -138222,10 +138222,10 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v14, v17, v19, v2, v22, v23, v6, v8 int32 - var v1, v11, v12, v13, v21 uintptr + var c, old, old1, r, v, v10, v14, v17, v2, v6, v8 int32 + var v1, v11, v12, v13 uintptr var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v19, v2, v21, v22, v23, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v11, v12, v13, v14, v17, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) @@ -138267,15 +138267,15 @@ _9: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v11 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v10 = X__uflow(tls, f) + v2 = X__uflow(tls, f) } - c = v10 - v13 = f + 140 + c = v2 + v12 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) for { @@ -138285,10 +138285,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1498) - v17 = v + v8 = v goto _18 _18: - old1 = v17 + old1 = v8 goto _16 _16: ; @@ -138298,30 +138298,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1498) - v14 = r + v6 = r goto _15 _15: ; - if !!(v14 != 0) { + if !!(v6 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1498) - v19 = old1 + v10 = old1 goto _20 _20: - if v19&int32(MAYBE_WAITERS) != 0 { - v21 = f + 140 - v22 = int32(1) - v23 = int32(1) - if v23 != 0 { - v23 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v13 = f + 140 + v14 = int32(1) + v17 = int32(1) + if v17 != 0 { + v17 = int32(FUTEX_PRIVATE) } - if v22 < Int32FromInt32(0) { - v22 = int32(INT_MAX) + if v14 < Int32FromInt32(0) { + v14 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)|v23), int64(v22)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v21), int64(Int32FromInt32(FUTEX_WAKE)), int64(v22)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 } return c } @@ -138340,7 +138340,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138365,7 +138365,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138378,12 +138378,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 int8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138419,7 +138419,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -138446,7 +138446,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -138454,14 +138454,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138473,14 +138473,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = int8(c) v11 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if int32(v10) == delim { break @@ -138532,7 +138532,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138543,7 +138543,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*int8)(unsafe.Pointer(s + uintptr(v6))) = int8(c) } *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 @@ -138722,17 +138722,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138748,9 +138748,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*int8)(unsafe.Pointer(buf)) = 0 (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138866,17 +138866,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138892,9 +138892,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138985,11 +138985,11 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v15, v18, v2, v20, v23, v24, v6, v8 int32 - var v1, v12, v13, v14, v22 uintptr + var old, old1, r, v, v10, v15, v2, v6, v8 int32 + var v1, v12 uintptr var v11 uint8 var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v15, v18, v2, v20, v22, v23, v24, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v15, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) @@ -139032,16 +139032,16 @@ _9: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v11 = Uint8FromInt32(c) - v13 = f + 40 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - *(*uint8)(unsafe.Pointer(v12)) = v11 - v10 = Int32FromUint8(v11) + v12 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v12)) + *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v11 + v2 = Int32FromUint8(v11) } else { - v10 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v10 - v14 = f + 140 + c = v2 + v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) for { @@ -139051,10 +139051,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1511) - v18 = v + v6 = v goto _19 _19: - old1 = v18 + old1 = v6 goto _17 _17: ; @@ -139064,30 +139064,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1511) - v15 = r + v2 = r goto _16 _16: ; - if !!(v15 != 0) { + if !!(v2 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) - v20 = old1 + v8 = old1 goto _21 _21: - if v20&int32(MAYBE_WAITERS) != 0 { - v22 = f + 140 - v23 = int32(1) - v24 = int32(1) - if v24 != 0 { - v24 = int32(FUTEX_PRIVATE) + if v8&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v10 = int32(1) + v15 = int32(1) + if v15 != 0 { + v15 = int32(FUTEX_PRIVATE) } - if v23 < Int32FromInt32(0) { - v23 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)|v24), int64(v23)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)), int64(v23)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -139109,7 +139109,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139145,7 +139145,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139171,11 +139171,11 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v15, v18, v2, v20, v23, v24, v6, v8 int32 - var v1, v12, v13, v14, v22 uintptr + var old, old1, r, v, v10, v15, v2, v6, v8 int32 + var v1, v12 uintptr var v11 uint8 var v4 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v13, v14, v15, v18, v2, v20, v22, v23, v24, v4, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v11, v12, v15, v2, v4, v6, v8 v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) @@ -139218,16 +139218,16 @@ _9: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v11 = Uint8FromInt32(c) - v13 = f + 40 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - *(*uint8)(unsafe.Pointer(v12)) = v11 - v10 = Int32FromUint8(v11) + v12 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v12)) + *(*uintptr)(unsafe.Pointer(v12)) = *(*uintptr)(unsafe.Pointer(v12)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v11 + v2 = Int32FromUint8(v11) } else { - v10 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v2 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v10 - v14 = f + 140 + c = v2 + v1 = f + 140 // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) for { @@ -139237,10 +139237,10 @@ _9: // : "=r"(v) // : "ZC"(*p)); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 5, __ccgo_ts+1511) - v18 = v + v6 = v goto _19 _19: - old1 = v18 + old1 = v6 goto _17 _17: ; @@ -139250,30 +139250,30 @@ _9: // : "=r"(r), "=ZC"(*p) // : "0"(v) : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 16, __ccgo_ts+1511) - v15 = r + v2 = r goto _16 _16: ; - if !!(v15 != 0) { + if !!(v2 != 0) { break } } // __asm__ __volatile__ ("dbar 0" : : : "memory"); X__assert_fail(tls, __ccgo_ts+350, __ccgo_ts+385, 49, __ccgo_ts+1511) - v20 = old1 + v8 = old1 goto _21 _21: - if v20&int32(MAYBE_WAITERS) != 0 { - v22 = f + 140 - v23 = int32(1) - v24 = int32(1) - if v24 != 0 { - v24 = int32(FUTEX_PRIVATE) + if v8&int32(MAYBE_WAITERS) != 0 { + v12 = f + 140 + v10 = int32(1) + v15 = int32(1) + if v15 != 0 { + v15 = int32(FUTEX_PRIVATE) } - if v23 < Int32FromInt32(0) { - v23 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)|v24), int64(v23)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v22), int64(Int32FromInt32(FUTEX_WAKE)), int64(v23)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -139295,7 +139295,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139323,7 +139323,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139353,7 +139353,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -139689,7 +139689,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139724,7 +139724,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139760,7 +139760,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139794,7 +139794,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -139811,12 +139811,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -139833,10 +139833,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139845,13 +139845,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140127,7 +140127,7 @@ func _pad3(tls *TLS, f uintptr, c int8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -140141,13 +140141,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = int8(int32(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140159,45 +140159,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*int8)(unsafe.Pointer(v4)) = Int8FromUint64(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*int8)(unsafe.Pointer(v2)) = Int8FromUint64(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -140212,13 +140212,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]int8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140227,7 +140227,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]int8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1576 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -140240,21 +140240,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*int8)(unsafe.Pointer(v10)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v11)) = int8(v12) - estr-- - v13 = estr - *(*int8)(unsafe.Pointer(v13)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*int8)(unsafe.Pointer(v14)) = int8(int32(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8(int32(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*int8)(unsafe.Pointer(v15)) = int8('.') + v5 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v5)) = int8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140366,46 +140366,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -140421,22 +140421,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -140455,21 +140455,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -140481,8 +140481,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -140492,10 +140492,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -140503,15 +140503,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -140523,23 +140523,23 @@ _4: } } if pl != 0 && int32(*(*int8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -140550,8 +140550,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -140570,14 +140570,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -140591,8 +140591,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -140616,21 +140616,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -140643,31 +140643,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*int8)(unsafe.Pointer(v43)) = int8('0') + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*int8)(unsafe.Pointer(v44)) = int8(v45) - estr-- - v46 = estr - *(*int8)(unsafe.Pointer(v46)) = int8(t) + *(*int8)(unsafe.Pointer(v5)) = int8(v7) + estr = estr - 1 + v5 = estr + *(*int8)(unsafe.Pointer(v5)) = int8(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140691,15 +140691,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*int8)(unsafe.Pointer(v48)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*int8)(unsafe.Pointer(v49)) = int8('0') + s2 = s2 - 1 + v5 = s2 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140717,21 +140717,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*int8)(unsafe.Pointer(v51)) = int8('0') + s3 = s3 - 1 + v5 = s3 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, int8('0'), p+int32(9), int32(9), 0) } else { @@ -140745,30 +140745,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*int8)(unsafe.Pointer(v54)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*int8)(unsafe.Pointer(v55)) = int8('0') + s4 = s4 - 1 + v5 = s4 + *(*int8)(unsafe.Pointer(v5)) = int8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+558, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -140780,11 +140780,11 @@ _4: } _pad3(tls, f, int8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -140803,7 +140803,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -140811,19 +140811,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]int8 var _ /* mb at bp+48 */ [4]int8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -140836,7 +140836,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -140849,7 +140849,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -140859,8 +140859,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140875,10 +140875,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -140886,11 +140886,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt8(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -140902,7 +140902,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -140911,19 +140911,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -140936,16 +140936,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -140953,7 +140953,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140969,7 +140969,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(int32(*(*int8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -141008,11 +141008,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141088,14 +141088,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141121,10 +141121,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141139,7 +141139,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -141157,12 +141157,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*int8)(unsafe.Pointer(v35)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*int8)(unsafe.Pointer(v8)) = Int8FromUint64(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141176,24 +141176,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1617 + v8 = __ccgo_ts + 1617 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*int8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141207,23 +141207,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -141236,28 +141236,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, int8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141322,7 +141322,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141331,7 +141331,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -141357,12 +141357,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -141401,11 +141401,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -141459,7 +141459,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -141473,17 +141473,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -141506,99 +141506,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -141609,33 +141609,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -141689,14 +141689,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -141714,85 +141714,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -141806,10 +141806,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -141817,11 +141817,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -141833,36 +141833,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -141875,16 +141875,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*int8)(unsafe.Pointer(bp)) = int8(c) @@ -141895,12 +141895,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -141919,23 +141919,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v73))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -141944,40 +141944,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*int8)(unsafe.Pointer(s + uintptr(v79))) = int8(c) + v64 = i + i = i + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v64))) = int8(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141985,7 +141985,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142008,26 +142008,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*int8)(unsafe.Pointer(s + uintptr(i))) = 0 } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142042,15 +142042,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -142059,6 +142051,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142074,20 +142074,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142099,7 +142099,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142108,7 +142108,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142280,7 +142280,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142337,7 +142337,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -142345,7 +142345,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]int8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -142358,7 +142358,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -142382,7 +142382,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142397,7 +142397,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -142408,7 +142408,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) goto _4 _4: ; @@ -142420,7 +142420,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -142435,13 +142435,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -142450,16 +142450,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -142515,7 +142515,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -142557,11 +142557,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -142582,27 +142582,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1617 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -142617,13 +142617,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -142675,7 +142675,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142684,7 +142684,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -142776,7 +142776,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142819,7 +142819,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -142840,14 +142840,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]int8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -142872,23 +142872,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142899,37 +142899,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142938,7 +142938,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -142948,7 +142948,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -142959,8 +142959,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -142973,9 +142973,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -143047,45 +143047,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143112,8 +143112,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143132,17 +143132,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143150,11 +143150,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -143169,27 +143169,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143199,17 +143199,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143218,16 +143218,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143285,23 +143285,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1660, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1678, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143309,7 +143309,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143321,7 +143321,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143330,7 +143330,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143411,8 +143411,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143426,11 +143426,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -143551,11 +143551,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -143573,9 +143573,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -143589,9 +143589,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -143636,9 +143636,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -143656,10 +143656,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -143778,9 +143778,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -143791,27 +143791,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (int32(*(*int8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -143833,19 +143833,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143875,19 +143875,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch int32(*(*int8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(int32(*(*int8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143912,11 +143912,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -143943,9 +143943,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]int8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -143962,9 +143962,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(int32((*(*[32]int8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = 0 *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144149,9 +144149,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144160,7 +144160,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -144171,7 +144171,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -144183,10 +144183,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144197,16 +144197,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144237,12 +144237,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144289,13 +144289,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -144311,17 +144311,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -144329,7 +144329,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -144360,9 +144360,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -144372,11 +144372,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144549,7 +144549,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144557,7 +144557,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144568,11 +144568,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144593,11 +144593,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144653,7 +144653,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144661,7 +144661,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144672,11 +144672,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144697,11 +144697,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144811,9 +144811,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -144829,9 +144829,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -144847,7 +144847,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -144855,19 +144855,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -144906,8 +144906,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -144920,7 +144920,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -144931,8 +144931,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -144959,9 +144959,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -144979,9 +144979,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -144989,14 +144989,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -145010,32 +145010,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145046,22 +145046,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -145077,23 +145077,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -145109,18 +145109,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -145136,170 +145136,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145309,27 +145309,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145471,29 +145471,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145528,22 +145528,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145551,10 +145551,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -145567,12 +145567,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145602,7 +145602,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -145627,9 +145627,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145642,14 +145642,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) } for { @@ -145660,42 +145660,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*int8)(unsafe.Pointer(v6)) = *(*int8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*int8)(unsafe.Pointer(v2)) = *(*int8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*int8)(unsafe.Pointer(d + uintptr(n))) = *(*int8)(unsafe.Pointer(s + uintptr(n))) } } @@ -145722,7 +145722,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -145780,9 +145780,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -145813,8 +145813,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -145830,8 +145830,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -145861,8 +145861,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 int8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 int8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -145876,8 +145876,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -145898,16 +145898,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -145946,9 +145946,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 int8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 int8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -145961,9 +145961,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*int8)(unsafe.Pointer(s)) != 0) { goto tail @@ -145978,7 +145978,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145986,19 +145986,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -146040,8 +146040,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146080,7 +146080,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146143,7 +146143,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -146164,7 +146164,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146198,8 +146198,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146220,10 +146220,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*int8)(unsafe.Pointer(c)) != 0) || !(*(*int8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, int32(*(*int8)(unsafe.Pointer(c))))) - int64(a)) @@ -146231,16 +146231,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*int8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -146249,7 +146249,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146331,12 +146331,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 int8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 int8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146352,9 +146352,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146367,7 +146367,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146376,19 +146376,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*int8)(unsafe.Pointer(s)) - *(*int8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*int8)(unsafe.Pointer(s)) + *(*int8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*int8)(unsafe.Pointer(d)) = 0 goto finish @@ -146427,7 +146427,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146447,7 +146447,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146463,7 +146463,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146474,9 +146474,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146502,21 +146502,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*int8)(unsafe.Pointer(v1)) = *(*int8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*int8)(unsafe.Pointer(v3)) = 0 + v1 = d + d = d + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 return a } @@ -146531,7 +146531,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146542,9 +146542,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146600,7 +146600,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*int8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146631,7 +146631,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*int8)(unsafe.Pointer(v1)) = 0 } else { end = uintptr(0) @@ -146657,7 +146657,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -146668,12 +146668,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -146685,10 +146685,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*int8)(unsafe.Pointer(c)) != 0) { @@ -146702,22 +146702,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*int8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*int8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -146726,18 +146726,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146869,29 +146869,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146928,7 +146928,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -146938,22 +146938,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146961,10 +146961,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -146977,12 +146977,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -147030,9 +147030,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -147040,17 +147040,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v1 = _p2 + _p2 = _p2 + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { _p2 = uintptr(0) } @@ -147064,9 +147064,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147074,18 +147074,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*int8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*int8)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*int8)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147128,7 +147128,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147144,7 +147144,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147173,12 +147173,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*int8)(unsafe.Pointer(dest)) = *(*int8)(unsafe.Pointer(src + 1)) *(*int8)(unsafe.Pointer(dest + 1)) = *(*int8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -147378,7 +147378,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147391,7 +147391,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -147409,21 +147409,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -147441,7 +147441,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147467,7 +147467,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147499,7 +147499,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147554,10 +147554,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -147567,7 +147567,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147581,23 +147581,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147606,29 +147606,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147665,16 +147665,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -147682,10 +147682,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -147698,12 +147698,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -147739,9 +147739,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147749,18 +147749,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147789,7 +147789,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -147814,7 +147814,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147842,7 +147842,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147861,8 +147861,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -147870,7 +147870,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147878,9 +147878,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -147904,7 +147904,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147937,7 +147937,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147962,27 +147962,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1720, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148045,7 +148045,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148256,7 +148256,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148307,38 +148307,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148346,15 +148346,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(int32(_days_in_month[months]) <= remdays) { break } - remdays -= int32(_days_in_month[months]) + remdays = remdays - int32(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148400,19 +148400,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148449,7 +148449,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148459,20 +148459,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148491,21 +148491,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148516,7 +148516,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148528,10 +148528,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148545,7 +148545,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148571,13 +148571,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148587,13 +148587,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]int8 var _ /* dummy_name at bp+308 */ [7]int8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1727) @@ -148617,7 +148617,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148631,7 +148631,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -148656,7 +148656,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1730) != 0) { @@ -148678,7 +148678,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -148705,7 +148705,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -148722,16 +148722,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -148751,7 +148751,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -148786,11 +148786,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148828,10 +148828,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -148860,7 +148860,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -148911,25 +148911,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -148972,16 +148972,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -149054,7 +149054,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -149071,8 +149071,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149082,15 +149082,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149100,11 +149100,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149500,9 +149500,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -149530,9 +149530,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149543,7 +149543,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149552,7 +149552,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149576,10 +149576,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1652 width = int32(2) def_pad = int32('0') @@ -149633,14 +149633,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -149657,7 +149657,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -149688,11 +149688,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -149701,14 +149701,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*int8)(unsafe.Pointer(v4)) = int8(Xtolower(tls, int32(*(*int8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -149732,11 +149732,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -149796,11 +149796,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1844, VaList(bp+8, val))) case int32('_'): @@ -149842,15 +149842,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]int8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -149862,21 +149862,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if int32(*(*int8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*int8)(unsafe.Pointer(s + uintptr(v2))) = *(*int8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if int32(*(*int8)(unsafe.Pointer(f))) == int32('-') || int32(*(*int8)(unsafe.Pointer(f))) == int32('_') || int32(*(*int8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = int32(*(*int8)(unsafe.Pointer(v3))) } v4 = BoolInt32(int32(*(*int8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -149893,7 +149893,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if int32(*(*int8)(unsafe.Pointer(f))) == int32('E') || int32(*(*int8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, int32(*(*int8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -149904,8 +149904,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if int32(*(*int8)(unsafe.Pointer(t))) == int32('+') || int32(*(*int8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(int32(*(*int8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(int32(*(*int8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -149914,8 +149914,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -149928,50 +149928,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v7))) = int8('-') - width-- + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v10))) = int8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*int8)(unsafe.Pointer(s + uintptr(v12))) = int8('0') + v2 = l + l = l + 1 + *(*int8)(unsafe.Pointer(s + uintptr(v2))) = int8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -150005,15 +150005,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -150037,21 +150037,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if int32(*(*int8)(unsafe.Pointer(s))) != int32(*(*int8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if int32(*(*int8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -150061,7 +150061,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch int32(*(*int8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150158,7 +150158,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150213,19 +150213,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*int8)(unsafe.Pointer(s)) != 0; v48 { - v45 = int32(*(*int8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*int8)(unsafe.Pointer(s)) != 0; v8 { + v1 = int32(*(*int8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150237,7 +150237,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150245,7 +150245,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150309,7 +150309,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150322,9 +150322,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if int32(*(*int8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if int32(*(*int8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150343,13 +150343,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150364,30 +150364,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if int32(*(*int8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if int32(*(*int8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(Uint32FromInt8(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + int32(*(*int8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150407,13 +150407,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -150612,7 +150612,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -150620,7 +150620,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -150632,7 +150632,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -150678,40 +150678,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151105,7 +151105,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*int8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = 0 @@ -151258,7 +151258,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go index 594b075..39c5d6e 100644 --- a/vendor/modernc.org/libc/ccgo_linux_ppc64le.go +++ b/vendor/modernc.org/libc/ccgo_linux_ppc64le.go @@ -639,14 +639,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -655,8 +655,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -987,18 +987,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -1030,9 +1030,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -1082,9 +1082,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1128,18 +1128,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1147,18 +1147,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1217,8 +1217,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1239,42 +1239,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1288,11 +1288,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1302,17 +1302,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1323,11 +1323,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1340,17 +1340,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1363,11 +1363,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1379,8 +1379,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1396,92 +1396,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1514,14 +1514,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1535,32 +1535,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1579,11 +1579,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1598,12 +1598,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1615,32 +1615,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1659,11 +1659,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1930,18 +1930,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1949,18 +1949,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1973,8 +1973,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1995,42 +1995,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -2044,11 +2044,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2057,17 +2057,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2078,11 +2078,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2097,17 +2097,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2120,11 +2120,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2136,8 +2136,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2153,92 +2153,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2282,13 +2282,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2303,29 +2303,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2356,8 +2356,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2365,22 +2365,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2402,13 +2402,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2423,29 +2423,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2453,21 +2453,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2481,18 +2481,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2515,18 +2515,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2534,18 +2534,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2556,15 +2556,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2607,15 +2607,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2658,11 +2658,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2672,15 +2672,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2705,50 +2705,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7602,13 +7602,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7664,14 +7664,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7686,14 +7686,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= X__libc.Fpage_size + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7702,7 +7702,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -9078,16 +9078,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9096,10 +9096,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9108,16 +9108,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9126,16 +9126,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -9144,58 +9144,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9215,7 +9215,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9226,12 +9226,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9239,36 +9239,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9276,9 +9276,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9287,10 +9287,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9337,9 +9337,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9356,25 +9356,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9385,11 +9385,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9414,7 +9414,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9427,7 +9427,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9444,13 +9444,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9463,7 +9463,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9488,7 +9488,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9496,7 +9496,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9515,9 +9515,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9526,7 +9526,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] @@ -11409,7 +11409,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11436,14 +11436,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11453,8 +11453,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11489,35 +11489,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11530,10 +11530,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11547,19 +11547,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11570,7 +11570,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11586,10 +11586,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11598,7 +11598,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11608,23 +11608,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11655,12 +11655,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11670,10 +11670,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11693,11 +11693,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11712,11 +11712,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11728,12 +11728,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11942,7 +11942,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11950,60 +11950,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12016,7 +12016,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12060,7 +12060,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12077,8 +12077,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -12089,8 +12089,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -12130,15 +12130,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12169,7 +12169,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12208,7 +12208,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12238,13 +12238,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v5)) = uint8('$') i = uint32(0) for { @@ -12255,7 +12255,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -12455,7 +12455,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12465,7 +12465,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12493,7 +12493,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12510,7 +12510,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12558,7 +12558,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12575,8 +12575,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12587,8 +12587,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12600,15 +12600,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12632,7 +12632,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12675,7 +12675,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12708,7 +12708,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12735,7 +12735,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12749,7 +12749,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12763,7 +12763,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12793,11 +12793,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12807,7 +12807,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -13117,7 +13117,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -13134,8 +13134,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -13146,8 +13146,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -13159,15 +13159,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13191,7 +13191,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -13219,7 +13219,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13244,7 +13244,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13277,7 +13277,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13304,7 +13304,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13318,7 +13318,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13332,7 +13332,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13362,11 +13362,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13376,7 +13376,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -13524,9 +13524,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13538,18 +13538,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17665,8 +17665,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22383,7 +22383,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22422,10 +22422,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22491,15 +22491,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22510,15 +22510,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -25073,10 +25073,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -25111,16 +25111,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -25190,7 +25190,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25310,7 +25310,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25412,7 +25412,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25424,7 +25424,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25869,7 +25869,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25893,7 +25893,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25937,7 +25937,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -26102,9 +26102,9 @@ func Xfeclearexcept(tls *TLS, mask int32) (r int32) { trc("tls=%v mask=%v, (%v:)", tls, mask, origin(2)) defer func() { trc("-> %v", r) }() } - mask &= int32(FE_ALL_EXCEPT) + mask = mask & int32(FE_ALL_EXCEPT) if mask&int32(FE_INVALID) != 0 { - mask |= int32(FE_ALL_INVALID) + mask = mask | int32(FE_ALL_INVALID) } _set_fpscr(tls, _get_fpscr(tls)&int64(^mask)) return 0 @@ -26115,9 +26115,9 @@ func Xferaiseexcept(tls *TLS, mask int32) (r int32) { trc("tls=%v mask=%v, (%v:)", tls, mask, origin(2)) defer func() { trc("-> %v", r) }() } - mask &= int32(FE_ALL_EXCEPT) + mask = mask & int32(FE_ALL_EXCEPT) if mask&int32(FE_INVALID) != 0 { - mask |= int32(FE_INVALID_SOFTWARE) + mask = mask | int32(FE_INVALID_SOFTWARE) } _set_fpscr(tls, _get_fpscr(tls)|int64(mask)) return 0 @@ -26241,15 +26241,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26258,23 +26258,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26284,18 +26284,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26303,58 +26303,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26379,7 +26379,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26389,32 +26389,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26430,7 +26430,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26439,15 +26439,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26458,14 +26458,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26475,7 +26475,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26483,11 +26483,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26519,12 +26519,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26549,19 +26549,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26574,24 +26574,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26652,7 +26652,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26663,11 +26663,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26679,29 +26679,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26714,40 +26714,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26774,11 +26774,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26792,7 +26792,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26808,26 +26808,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26839,15 +26839,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26871,41 +26871,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26917,15 +26917,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26935,10 +26935,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26952,13 +26952,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26970,11 +26970,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26986,10 +26986,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -27008,7 +27008,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27024,16 +27024,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -27042,24 +27042,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -27067,12 +27067,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -27086,55 +27086,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27142,26 +27142,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27169,19 +27169,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27455,11 +27455,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27470,7 +27470,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27488,42 +27488,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27542,7 +27542,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27556,18 +27556,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27575,18 +27575,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27600,18 +27600,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27734,7 +27734,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') @@ -27749,21 +27749,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27806,7 +27806,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28551,7 +28551,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28760,7 +28760,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && Int32FromUint8(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = uint8(0) } @@ -29253,7 +29253,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30448,7 +30448,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31411,8 +31411,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31432,10 +31432,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31524,10 +31524,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98450,7 +98450,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98458,8 +98458,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98483,16 +98483,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98559,23 +98559,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98616,10 +98616,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98637,10 +98637,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98650,7 +98650,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]uint8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98838,11 +98838,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98855,7 +98855,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98864,27 +98864,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98910,11 +98910,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98973,8 +98973,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98987,7 +98987,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -99011,7 +99011,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -99036,13 +99036,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -99060,17 +99060,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -99079,9 +99079,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -99098,18 +99098,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -99181,7 +99181,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -99199,17 +99199,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -99300,7 +99300,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -99320,7 +99320,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*uint8)(unsafe.Pointer(v54)) = uint8(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -99338,7 +99338,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99347,17 +99347,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99369,24 +99369,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v57)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v60)) = uint8(v62) + *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99395,7 +99395,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99405,14 +99405,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*uint8)(unsafe.Pointer(v63)) = uint8(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*uint8)(unsafe.Pointer(v65)) = uint8(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99424,56 +99424,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*uint8)(unsafe.Pointer(v67)) = uint8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*uint8)(unsafe.Pointer(v69)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*uint8)(unsafe.Pointer(v71)) = uint8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*uint8)(unsafe.Pointer(v73)) = uint8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*uint8)(unsafe.Pointer(v75)) = uint8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*uint8)(unsafe.Pointer(v77)) = uint8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*uint8)(unsafe.Pointer(v79)) = uint8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*uint8)(unsafe.Pointer(v81)) = uint8(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*uint8)(unsafe.Pointer(v83)) = uint8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*uint8)(unsafe.Pointer(v85)) = uint8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*uint8)(unsafe.Pointer(v87)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99484,38 +99484,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*uint8)(unsafe.Pointer(v89)) = uint8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*uint8)(unsafe.Pointer(v91)) = uint8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*uint8)(unsafe.Pointer(v93)) = uint8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*uint8)(unsafe.Pointer(v95)) = uint8(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*uint8)(unsafe.Pointer(v97)) = uint8(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*uint8)(unsafe.Pointer(v99)) = uint8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*uint8)(unsafe.Pointer(v101)) = uint8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*uint8)(unsafe.Pointer(v103)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99546,7 +99546,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99623,8 +99623,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99638,11 +99638,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 570 + v1 = __ccgo_ts + 570 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99679,13 +99679,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99754,11 +99754,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]uint8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*uint8)(unsafe.Pointer(val)) != 0) { @@ -99787,7 +99787,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 579 @@ -99855,11 +99855,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99963,7 +99963,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99991,7 +99991,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -100068,7 +100068,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -100079,7 +100079,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100189,7 +100189,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -100203,7 +100203,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -100247,7 +100247,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100303,10 +100303,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]uint8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100342,7 +100342,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100355,7 +100355,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -100366,22 +100366,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + s = s - 1 + v3 = s + *(*uint8)(unsafe.Pointer(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100394,11 +100394,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 570 + v3 = __ccgo_ts + 570 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100432,9 +100432,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100448,15 +100448,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100468,9 +100468,9 @@ _4: for { switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100491,7 +100491,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100502,13 +100502,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100517,12 +100517,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100531,12 +100531,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100547,8 +100547,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100743,9 +100743,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100758,11 +100758,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100962,12 +100962,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100987,11 +100987,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101372,12 +101372,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101502,10 +101502,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101533,8 +101533,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101548,17 +101548,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101578,18 +101578,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101602,7 +101602,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101621,7 +101621,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101635,7 +101635,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101647,11 +101647,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101662,7 +101662,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101676,37 +101676,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101720,11 +101720,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101738,17 +101738,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101770,18 +101770,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101793,38 +101793,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101840,7 +101840,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101856,7 +101856,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101864,11 +101864,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101934,13 +101934,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -102097,12 +102097,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -102144,11 +102144,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102800,11 +102800,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102819,14 +102819,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102904,11 +102904,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -103021,11 +103021,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -103161,11 +103161,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -103329,12 +103329,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103372,8 +103372,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103624,7 +103624,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103633,7 +103633,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103650,10 +103650,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103773,12 +103773,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103814,11 +103814,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -104092,7 +104092,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -104127,12 +104127,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -104159,11 +104159,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -104277,7 +104277,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -104312,12 +104312,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104344,11 +104344,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104384,11 +104384,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104475,13 +104475,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104674,11 +104674,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104754,14 +104754,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104769,13 +104769,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104829,9 +104829,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104856,13 +104856,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104961,13 +104961,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -105102,7 +105102,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -105180,7 +105180,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -105237,7 +105237,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -105283,12 +105283,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105297,8 +105297,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105340,13 +105340,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105355,10 +105355,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105376,13 +105376,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105391,10 +105391,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105610,7 +105610,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105622,10 +105622,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105737,7 +105737,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) // __asm__ ("cntlzd %0, %1" : "=r"(x) : "r"(x)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 60, __ccgo_ts+614) @@ -105749,13 +105749,13 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105766,7 +105766,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { return float64(x1*y) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105799,7 +105799,7 @@ func Xfma(tls *TLS, x1 float64, y float64, z float64) (r1 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r) - r += float64(Tdouble_t(tiny*tiny) * (r - r)) + r = r + float64(Tdouble_t(tiny*tiny)*(r-r)) } } else { /* only round once when scaled */ @@ -105832,13 +105832,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105847,27 +105847,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105875,11 +105875,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105889,13 +105889,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105904,27 +105904,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105932,11 +105932,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105954,13 +105954,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105969,27 +105969,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105997,11 +105997,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -106011,13 +106011,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -106026,27 +106026,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -106054,11 +106054,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -106080,7 +106080,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -106093,7 +106093,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106141,13 +106141,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -106200,17 +106200,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106341,17 +106341,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106372,12 +106372,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106401,10 +106401,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106416,12 +106416,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106445,10 +106445,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106485,7 +106485,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106498,7 +106498,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106516,10 +106516,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106559,13 +106559,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106640,13 +106640,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106709,8 +106709,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106761,7 +106761,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106783,8 +106783,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106880,7 +106880,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -107036,7 +107036,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -107144,7 +107144,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -107224,7 +107224,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107369,7 +107369,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107477,7 +107477,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107568,7 +107568,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107715,7 +107715,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107822,7 +107822,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107904,7 +107904,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -108046,7 +108046,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -108153,7 +108153,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -108193,7 +108193,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108207,14 +108207,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -108257,7 +108257,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -108281,12 +108281,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -108299,8 +108299,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108315,7 +108315,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108340,7 +108340,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108353,14 +108353,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108387,15 +108387,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108461,7 +108461,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108471,11 +108471,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108489,7 +108489,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108500,14 +108500,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108521,7 +108521,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108544,12 +108544,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108561,8 +108561,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108577,7 +108577,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108602,7 +108602,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108615,14 +108615,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108648,13 +108648,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108691,7 +108691,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108700,11 +108700,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108813,8 +108813,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108920,7 +108920,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108928,11 +108928,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108944,20 +108944,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -109071,7 +109071,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -109177,7 +109177,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -109185,11 +109185,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -109201,20 +109201,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109342,9 +109342,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109370,31 +109370,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109494,8 +109494,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109690,7 +109690,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109700,7 +109700,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109790,7 +109790,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109800,7 +109800,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -109849,9 +109849,9 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109874,31 +109874,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110517,9 +110517,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110617,9 +110617,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110676,8 +110676,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110691,7 +110691,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110720,32 +110720,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110875,12 +110875,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110967,16 +110967,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -111046,11 +111046,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, x2 Tdouble_t var ix, iy Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -111069,19 +111069,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -111095,14 +111095,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -111114,43 +111114,43 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111582,8 +111582,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111591,10 +111591,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111602,10 +111602,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111689,13 +111689,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111753,8 +111753,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111762,10 +111762,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111773,10 +111773,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -112051,13 +112051,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -112073,10 +112073,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -112102,13 +112102,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -112124,10 +112124,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -112199,11 +112199,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -112212,11 +112212,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -112243,22 +112243,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112304,12 +112304,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112324,18 +112324,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112367,14 +112367,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112390,18 +112390,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112414,9 +112414,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112462,13 +112462,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112484,18 +112484,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112526,11 +112526,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112546,24 +112546,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112624,13 +112624,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112644,18 +112644,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112686,11 +112686,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112860,9 +112860,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112881,7 +112881,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112890,7 +112890,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112918,9 +112918,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -113030,7 +113030,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -113065,9 +113065,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -113077,13 +113077,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -113109,11 +113109,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -113128,18 +113128,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -113175,13 +113175,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -113195,18 +113195,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113223,28 +113223,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113442,8 +113442,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113543,7 +113543,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113556,7 +113556,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113626,7 +113626,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113639,10 +113639,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113653,7 +113653,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113800,12 +113800,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*uint8)(unsafe.Pointer(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) @@ -113856,7 +113856,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113865,7 +113865,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113899,7 +113899,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113911,7 +113911,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113923,7 +113923,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) return s @@ -114017,7 +114017,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -114032,11 +114032,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -114129,17 +114129,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114418,11 +114418,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114474,7 +114474,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114503,7 +114503,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114520,7 +114520,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114528,9 +114528,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114545,11 +114545,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114560,11 +114560,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114581,22 +114581,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114622,7 +114622,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+762, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114638,13 +114638,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 831 + v5 = __ccgo_ts + 831 } else { - v6 = __ccgo_ts + 738 + v5 = __ccgo_ts + 738 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114705,9 +114705,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint64 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall4(tls, int64(SYS_prlimit64), int64(Int32FromInt32(0)), int64(resource), int64(Int32FromInt32(0)), int64(rlim))))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114730,11 +114730,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114786,7 +114786,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114811,7 +114811,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -115099,15 +115099,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -115117,12 +115117,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -115170,7 +115170,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -115313,28 +115313,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*uint8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115344,29 +115344,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*uint8)(unsafe.Pointer(v7)) = cval + v1 = dest + dest = dest + 1 + *(*uint8)(unsafe.Pointer(v1)) = cval src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } } *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -115415,7 +115415,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+867, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115473,15 +115473,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(192) defer tls.Free(192) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+176 */ TFTW var _ /* new at bp+144 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115533,11 +115533,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel if h != 0 { @@ -115551,7 +115551,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115560,7 +115560,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) } @@ -115575,10 +115575,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115616,9 +115616,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115630,11 +115630,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115807,7 +115807,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115820,12 +115820,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]uint8 var _ /* stack at bp+0 */ [4097]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115860,27 +115860,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') - p++ + p = p + 1 /* Initial // is special. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v5] = uint8('/') + v4 = q + q = q + 1 + (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115890,17 +115890,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v7] = uint8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) - p += l + p = p + l up = 0 if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115909,8 +115909,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115939,23 +115939,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115963,10 +115963,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115974,7 +115974,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115988,26 +115988,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v11] = uint8('/') + v4 = l + l = l + 1 + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116531,19 +116531,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]uint8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116561,12 +116561,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v2] = uint8('\n') + v1 = l + l = l + 1 + (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+691, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116819,7 +116819,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -117064,11 +117064,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -117107,9 +117107,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -117118,10 +117118,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -117283,12 +117283,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + wn = wn - 1 goto _4 _4: } @@ -117303,44 +117303,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117360,76 +117360,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117578,31 +117578,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } @@ -117648,16 +117648,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117673,9 +117673,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]uint8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117689,9 +117689,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117711,13 +117711,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117736,13 +117736,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118953,9 +118953,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118966,8 +118966,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118979,20 +118979,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -119005,34 +119005,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -119046,17 +119046,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -119107,22 +119107,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -119144,9 +119144,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -119182,26 +119182,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*uint8)(unsafe.Pointer(v3)) = uint8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) } } else { *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -119214,7 +119214,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -119249,7 +119249,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119359,9 +119359,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119373,31 +119373,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -119405,7 +119405,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119747,7 +119747,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119759,7 +119759,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119799,11 +119799,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1018 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119846,9 +119846,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119857,15 +119857,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119882,7 +119882,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -119894,16 +119894,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -120006,7 +120006,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -120076,13 +120076,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -120213,7 +120213,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120278,15 +120278,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -120336,7 +120336,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120395,41 +120395,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120691,7 +120691,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120872,17 +120872,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120895,29 +120895,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8('.') - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+1049) } @@ -120927,15 +120927,15 @@ var _xdigits = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1058, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120950,7 +120950,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120968,14 +120968,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120988,35 +120988,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*uint8)(unsafe.Pointer(p)) != 0; v13 { - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*uint8)(unsafe.Pointer(z)) != 0; v18 { - v15 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { @@ -121030,7 +121030,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -121038,7 +121038,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]uint8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1082, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -121048,7 +121048,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -121066,14 +121066,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -121173,7 +121173,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8('%') Xstrcat(tls, bp+78, p) @@ -121302,7 +121302,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121405,12 +121405,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(320) defer tls.Free(320) - var r, v10, v21, v32 int64 - var r1, v1, v12, v13, v14, v2, v23, v24, v25, v3 int32 + var r, v10 int64 + var r1, v1, v2, v3 int32 var tv uintptr - var v15, v16, v17, v18, v19, v20, v26, v27, v28, v29, v30, v31, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t var _ /* tv32 at bp+296 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_getsockopt) v2 = int32(__SC_getsockopt) v3 = 0 @@ -121476,49 +121476,49 @@ _11: *(*[1]Tsocklen_t)(unsafe.Pointer(bp + 96)) = [1]Tsocklen_t{ 0: uint32(16), } - v12 = int32(SYS_getsockopt) - v13 = int32(__SC_getsockopt) - v14 = 0 - v15 = int64(fd) - v16 = int64(level) - v17 = int64(optname) - v18 = int64(bp + 296) - v19 = int64(bp + 96) - v20 = int64(Int32FromInt32(0)) - if v14 != 0 { - r = ___syscall_cp(tls, int64(v12), v15, v16, v17, v18, v19, v20) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(bp + 296) + v8 = int64(bp + 96) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v12), v15, v16, v17, v18, v19, v20) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v21 = r + v10 = r goto _22 } - if v14 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 200)) = [6]int64{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v13), int64(bp+200), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+200), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 248)) = [6]int64{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v13), int64(bp+248)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+248)) } - v21 = r + v10 = r goto _22 _22: - r1 = int32(v21) + r1 = int32(v10) if r1 < 0 { break } @@ -121538,49 +121538,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v23 = int32(SYS_getsockopt) - v24 = int32(__SC_getsockopt) - v25 = 0 - v26 = int64(fd) - v27 = int64(level) - v28 = int64(optname) - v29 = int64(optval) - v30 = int64(optlen) - v31 = int64(Int32FromInt32(0)) - if v25 != 0 { - r = ___syscall_cp(tls, int64(v23), v26, v27, v28, v29, v30, v31) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(optval) + v8 = int64(optlen) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v23), v26, v27, v28, v29, v30, v31) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v32 = r + v10 = r goto _33 } - if v25 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 200)) = [6]int64{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v24), int64(bp+200), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+200), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 248)) = [6]int64{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v24), int64(bp+248)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+248)) } - v32 = r + v10 = r goto _33 _33: - r1 = int32(v32) + r1 = int32(v10) break } } @@ -121630,7 +121630,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -121642,16 +121642,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121822,7 +121822,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121868,14 +121868,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121897,9 +121897,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121909,11 +121909,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121961,7 +121961,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121991,7 +121991,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -122018,12 +122018,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Uint8FromUint8(':') @@ -122150,7 +122150,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -122164,11 +122164,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -122189,7 +122189,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -122201,11 +122201,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -122215,7 +122215,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { @@ -122226,9 +122226,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*uint8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -122236,22 +122236,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -122268,15 +122268,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -122289,7 +122289,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -122297,16 +122297,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -122409,7 +122409,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -122459,14 +122459,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122474,23 +122474,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122499,9 +122499,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122519,14 +122519,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122549,15 +122549,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122576,7 +122576,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122584,26 +122584,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*uint8)(unsafe.Pointer(p)) != 0; v17 { - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*uint8)(unsafe.Pointer(v18)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122615,35 +122615,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*uint8)(unsafe.Pointer(p)) != 0; v23 { - v20 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*uint8)(unsafe.Pointer(z)) != 0; v28 { - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { @@ -122653,11 +122653,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122704,7 +122704,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122749,14 +122749,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122778,7 +122778,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122793,7 +122793,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122818,13 +122818,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]uint8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122838,19 +122838,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*uint8)(unsafe.Pointer(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122881,23 +122881,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122983,7 +122983,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -123019,7 +123019,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -123039,7 +123039,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -123049,7 +123049,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*uint8)(unsafe.Pointer(canon)) = uint8(0) if name != 0 { @@ -123067,7 +123067,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -123101,7 +123101,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -123110,18 +123110,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -123139,7 +123139,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -123158,7 +123158,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -123212,31 +123212,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -123383,19 +123383,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*uint8)(unsafe.Pointer(p)) != 0; v19 { - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -123407,9 +123407,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1101, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -123417,18 +123417,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123591,34 +123591,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123633,21 +123633,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123660,14 +123660,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123694,7 +123694,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123705,18 +123705,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123733,8 +123733,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123769,22 +123769,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123795,7 +123795,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123918,7 +123918,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -124039,7 +124039,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -124051,11 +124051,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -124107,11 +124107,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -124120,14 +124120,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 40 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 40 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -124145,10 +124145,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v11 int64 var r1 Tssize_t - var v1, v2, v3, v4 int32 + var v1, v2, v3 int32 var v10, v5, v6, v7, v8, v9 Tsyscall_arg_t var _ /* h at bp+96 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v10, v11, v2, v3, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -124158,25 +124158,25 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 msg = bp + 96 } - v2 = int32(SYS_recvmsg) - v3 = int32(__SC_recvmsg) - v4 = int32(1) + v1 = int32(SYS_recvmsg) + v2 = int32(__SC_recvmsg) + v3 = int32(1) v5 = int64(fd) v6 = int64(msg) v7 = int64(flags) v8 = int64(Int32FromInt32(0)) v9 = int64(Int32FromInt32(0)) v10 = int64(Int32FromInt32(0)) - if v4 != 0 { - r = ___syscall_cp(tls, int64(v2), v5, v6, v7, v8, v9, v10) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v5, v6, v7, v8, v9, v10) } else { - r = X__syscall6(tls, int64(v2), v5, v6, v7, v8, v9, v10) + r = X__syscall6(tls, int64(v1), v5, v6, v7, v8, v9, v10) } if r != int64(-Int32FromInt32(ENOSYS)) { v11 = r goto _12 } - if v4 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp)) = [6]int64{ 0: v5, 1: v6, @@ -124185,7 +124185,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { 4: v9, 5: v10, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v3), int64(bp), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 48)) = [6]int64{ 0: v5, @@ -124195,7 +124195,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { 4: v9, 5: v10, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v3), int64(bp+48)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+48)) } v11 = r goto _12 @@ -124232,7 +124232,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -124260,7 +124260,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -124403,7 +124403,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -124471,9 +124471,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -124493,7 +124493,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -124514,7 +124514,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124584,7 +124584,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124598,7 +124598,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -124632,7 +124632,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124659,7 +124659,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124687,7 +124687,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124709,13 +124709,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124754,7 +124754,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124768,7 +124768,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124785,10 +124785,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124806,7 +124806,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124865,7 +124865,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124917,7 +124917,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124940,7 +124940,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124970,9 +124970,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124987,11 +124987,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -125021,16 +125021,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]uint8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -125067,7 +125067,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1216) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -125080,103 +125080,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1223) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1233) if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1242, uint64(10)) != 0); v11 { - v8 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1242, uint64(10)) != 0); v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1253, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1260, uint64(6)) != 0; !v24 { - v21 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1253, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1260, uint64(6)) != 0; !v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -125236,7 +125236,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -125257,13 +125257,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1216) defer tls.Free(1216) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v14 int64 - var v1, v5, v6, v7 int32 + var v1, v5, v6 int32 var v10, v11, v12, v13, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+152 */ [66]Tcmsghdr var _ /* h at bp+96 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v5, v6, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -125292,33 +125292,33 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) - v6 = int32(__SC_sendmsg) - v7 = int32(1) + v1 = int32(SYS_sendmsg) + v5 = int32(__SC_sendmsg) + v6 = int32(1) v8 = int64(fd) v9 = int64(msg) v10 = int64(flags) v11 = int64(Int32FromInt32(0)) v12 = int64(Int32FromInt32(0)) v13 = int64(Int32FromInt32(0)) - if v7 != 0 { - r = ___syscall_cp(tls, int64(v5), v8, v9, v10, v11, v12, v13) + if v6 != 0 { + r = ___syscall_cp(tls, int64(v1), v8, v9, v10, v11, v12, v13) } else { - r = X__syscall6(tls, int64(v5), v8, v9, v10, v11, v12, v13) + r = X__syscall6(tls, int64(v1), v8, v9, v10, v11, v12, v13) } if r != int64(-Int32FromInt32(ENOSYS)) { v14 = r goto _15 } - if v7 != 0 { + if v6 != 0 { *(*[6]int64)(unsafe.Pointer(bp)) = [6]int64{ 0: v8, 1: v9, @@ -125327,7 +125327,7 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { 4: v12, 5: v13, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v6), int64(bp), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v5), int64(bp), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 48)) = [6]int64{ 0: v8, @@ -125337,7 +125337,7 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { 4: v12, 5: v13, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v6), int64(bp+48)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v5), int64(bp+48)) } v14 = r goto _15 @@ -125428,14 +125428,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(304) defer tls.Free(304) - var r, v10, v22, v33 int64 - var r1, v1, v13, v14, v15, v2, v24, v25, v26, v3 int32 + var r, v10 int64 + var r1, v1, v2, v3 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v12 uint64 - var v16, v17, v18, v19, v20, v21, v27, v28, v29, v30, v31, v32, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9 + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_setsockopt) v2 = int32(__SC_setsockopt) v3 = 0 @@ -125513,49 +125513,49 @@ _11: 0: s, 1: int64(Int32FromUint64(v12)), } - v13 = int32(SYS_setsockopt) - v14 = int32(__SC_setsockopt) - v15 = 0 - v16 = int64(fd) - v17 = int64(level) - v18 = int64(optname) - v19 = int64(bp + 96) - v20 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v21 = int64(Int32FromInt32(0)) - if v15 != 0 { - r = ___syscall_cp(tls, int64(v13), v16, v17, v18, v19, v20, v21) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(bp + 96) + v8 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v13), v16, v17, v18, v19, v20, v21) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v22 = r + v10 = r goto _23 } - if v15 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 208)) = [6]int64{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v14), int64(bp+208), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+208), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 256)) = [6]int64{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v14), int64(bp+256)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+256)) } - v22 = r + v10 = r goto _23 _23: - r1 = int32(v22) + r1 = int32(v10) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -125568,49 +125568,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v24 = int32(SYS_setsockopt) - v25 = int32(__SC_setsockopt) - v26 = 0 - v27 = int64(fd) - v28 = int64(level) - v29 = int64(optname) - v30 = int64(optval) - v31 = Int64FromUint32(optlen) - v32 = int64(Int32FromInt32(0)) - if v26 != 0 { - r = ___syscall_cp(tls, int64(v24), v27, v28, v29, v30, v31, v32) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(optval) + v8 = Int64FromUint32(optlen) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v24), v27, v28, v29, v30, v31, v32) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v33 = r + v10 = r goto _34 } - if v26 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 208)) = [6]int64{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v25), int64(bp+208), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+208), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 256)) = [6]int64{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v25), int64(bp+256)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+256)) } - v33 = r + v10 = r goto _34 _34: - r1 = int32(v33) + r1 = int32(v10) break } } @@ -126006,18 +126006,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126032,14 +126032,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]uint8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -126061,11 +126061,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -126105,11 +126105,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -126123,12 +126123,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -126141,11 +126141,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -126170,14 +126170,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -126239,9 +126239,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -126254,7 +126254,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -126371,7 +126371,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126383,13 +126383,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126410,32 +126410,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126447,12 +126447,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -126472,21 +126472,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -126509,8 +126509,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -126523,7 +126523,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -126567,7 +126567,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -126595,7 +126595,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -126606,17 +126606,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -126631,18 +126631,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -126665,18 +126665,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126691,11 +126691,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]uint8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -126717,11 +126717,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]uint8)(unsafe.Pointer(bp + 44)) = [11]uint8{} @@ -126773,11 +126773,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126941,7 +126941,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126955,10 +126955,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126979,57 +126979,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v10)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v14)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -127097,10 +127097,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -127186,7 +127186,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -127201,15 +127201,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -127612,7 +127612,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -127684,8 +127684,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -127695,14 +127695,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127758,7 +127758,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127774,7 +127774,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127802,7 +127802,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127818,7 +127818,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127846,7 +127846,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127862,7 +127862,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127892,11 +127892,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1403) seen_eacces = 0 @@ -127923,7 +127923,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } @@ -127943,9 +127943,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -128428,7 +128428,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -128436,12 +128436,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -128450,12 +128450,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -128464,7 +128464,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -128517,22 +128517,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -128550,15 +128550,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -128576,7 +128576,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -128584,7 +128584,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -128592,13 +128592,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { @@ -128612,26 +128612,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128641,8 +128641,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -128667,13 +128667,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128693,18 +128693,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v10)))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128712,7 +128712,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -128722,22 +128722,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128759,7 +128759,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128771,11 +128771,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128785,7 +128785,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -128796,9 +128796,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -128806,7 +128806,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128834,7 +128834,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128846,7 +128846,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128878,7 +128878,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128933,13 +128933,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(144) defer tls.Free(144) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep uint8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128951,9 +128951,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128970,8 +128970,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128991,7 +128991,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -129000,9 +129000,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -129011,9 +129011,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -129027,7 +129027,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { @@ -129062,19 +129062,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = uint8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 606 + v2 = __ccgo_ts + 606 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -129084,9 +129084,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -129124,11 +129124,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*uint8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -129174,13 +129174,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 uint8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 uint8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -129188,16 +129188,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*uint8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1437) + v2 = Xgetenv(tls, __ccgo_ts+1437) } - home = v3 + home = v2 if !(home != 0) { if *(*uint8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -129232,20 +129232,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) } if *(*uint8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v13))) = uint8(0) + v1 = delim + *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -129319,7 +129319,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -129327,7 +129327,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -129341,7 +129341,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -129357,7 +129357,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -129371,7 +129371,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -129396,7 +129396,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -129792,7 +129792,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129833,7 +129833,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -129843,7 +129843,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129941,7 +129941,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129979,16 +129979,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -130001,8 +130001,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -130013,16 +130013,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -130033,11 +130033,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -130086,11 +130086,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]uint8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -130115,7 +130115,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('[') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*uint8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -130130,21 +130130,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -130152,7 +130152,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -130160,9 +130160,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -130195,11 +130195,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -130212,7 +130212,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -130271,11 +130271,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -130294,13 +130294,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -130313,7 +130313,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -130340,12 +130340,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -130359,7 +130359,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -130382,7 +130382,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -130408,11 +130408,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('['): @@ -130454,7 +130454,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { case 0: @@ -130468,12 +130468,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -130488,20 +130488,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -130517,7 +130517,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -130526,47 +130526,47 @@ _2: if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -130575,7 +130575,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -130584,7 +130584,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -130628,8 +130628,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -130647,12 +130647,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -130661,7 +130661,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -130669,28 +130669,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -130729,7 +130729,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130753,7 +130753,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130774,24 +130774,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130932,7 +130932,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130992,7 +130992,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -131033,7 +131033,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -131046,7 +131046,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -131064,7 +131064,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -131077,7 +131077,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -131096,7 +131096,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -131131,13 +131131,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -131145,8 +131145,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -131181,7 +131181,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -131251,20 +131251,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -131348,26 +131348,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -131381,7 +131381,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -131475,7 +131475,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -131497,13 +131497,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -131558,8 +131558,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131798,7 +131798,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131839,7 +131839,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131882,7 +131882,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131899,8 +131899,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131963,7 +131963,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131973,7 +131973,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131983,7 +131983,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -132012,7 +132012,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -132027,7 +132027,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -132038,7 +132038,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -132046,7 +132046,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -132072,7 +132072,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -132087,7 +132087,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -132095,7 +132095,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -132109,9 +132109,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -132140,7 +132140,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -132148,13 +132148,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -132455,9 +132455,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -132511,7 +132511,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -132526,7 +132526,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -132536,13 +132536,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -132560,7 +132560,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -132581,14 +132581,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -132603,7 +132603,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132786,7 +132786,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132831,7 +132831,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132841,12 +132841,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -132868,7 +132868,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132899,7 +132899,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132911,7 +132911,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132974,7 +132974,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -133007,7 +133007,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -133048,11 +133048,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -133095,7 +133095,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -133147,13 +133147,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -133206,44 +133206,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -133254,10 +133254,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -133265,10 +133265,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -133291,7 +133291,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -133314,7 +133314,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -133335,18 +133335,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -133381,7 +133381,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -133430,7 +133430,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -133461,7 +133461,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -133485,7 +133485,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -133566,13 +133566,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -133636,7 +133636,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -133647,12 +133647,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -133660,10 +133660,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -133733,7 +133733,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133783,7 +133783,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133814,21 +133814,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133839,18 +133839,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133921,7 +133921,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133949,9 +133949,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133978,7 +133978,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -134034,8 +134034,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -134058,7 +134058,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -134074,23 +134074,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -134245,7 +134245,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -134316,7 +134316,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -134339,7 +134339,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -134367,8 +134367,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -134411,8 +134411,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -134468,11 +134468,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -134551,7 +134551,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -134583,7 +134583,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -134604,9 +134604,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -134615,11 +134615,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -134628,9 +134628,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -134639,14 +134639,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -134656,13 +134656,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134803,17 +134803,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134823,9 +134823,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -134840,15 +134840,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134995,8 +134995,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -135227,7 +135227,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) bp := tls.Alloc(80) defer tls.Free(80) var old, r, r1, v, v15, v19, v24, v28, v5, v9 int32 - var v1, v12, v13, v14, v18, v22, v23, v27, v3, v31, v32, v33, v4, v8 uintptr + var v1, v12, v13, v14, v18, v22, v23, v27, v3, v4, v8 uintptr var v2 int64 var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+48 */ Tk_sigaction @@ -135235,7 +135235,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v12, v13, v14, v15, v18, v19, v2, v22, v23, v24, v27, v28, v3, v31, v32, v33, v4, v5, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, r1, v, v1, v12, v13, v14, v15, v18, v19, v2, v22, v23, v24, v27, v28, v3, v4, v5, v8, v9 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -135382,24 +135382,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r2 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(0x04000000) if Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags)&uint32(4) != 0 { - v31 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v31 = __ccgo_fp(X__restore) + v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v31 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v32 = bp + 16 + v1 = bp + 16 } else { - v32 = uintptr(0) + v1 = uintptr(0) } if old1 != 0 { - v33 = bp + 48 + v3 = bp + 48 } else { - v33 = uintptr(0) + v3 = uintptr(0) } - r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v32), int64(v33), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r1 = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r1 != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) @@ -135501,7 +135501,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135577,7 +135577,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -135616,7 +135616,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135954,7 +135954,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -136121,7 +136121,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -136324,7 +136324,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r goto _1 _1: ; - i++ + i = i + 1 } } r = int32(X__syscall3(tls, int64(SYS_futimesat), int64(fd), int64(path), int64(tv))) @@ -136433,19 +136433,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -136490,7 +136490,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -136599,13 +136599,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -136627,12 +136627,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -136656,11 +136656,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -136669,11 +136669,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -136703,9 +136703,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136719,9 +136719,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -136742,8 +136742,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -136754,9 +136754,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136925,8 +136925,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136935,9 +136935,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -137008,7 +137008,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -137121,16 +137121,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -137144,7 +137144,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137158,11 +137158,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -137183,9 +137183,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -137201,10 +137201,10 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v12, v17, v21, v23, v26, v27, v3, v8 int32 - var v1, v13, v14, v15, v16, v2, v20, v25, v7 uintptr + var c, old, old1, r, v, v10, v12, v17, v21, v3, v8 int32 + var v1, v13, v14, v15, v2, v7 uintptr var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v2, v20, v21, v23, v25, v26, v27, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v17, v2, v21, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) @@ -137243,58 +137243,58 @@ _11: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v12 = X__uflow(tls, f) + v3 = X__uflow(tls, f) } - c = v12 - v15 = f + 140 + c = v3 + v7 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) for { - v20 = v15 + v14 = v7 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1550) - v21 = v + v10 = v goto _22 _22: - old1 = v21 + old1 = v10 goto _19 _19: ; - v16 = v15 + v13 = v7 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1550) - v17 = r & int32(0x20000000) + v8 = r & int32(0x20000000) goto _18 _18: ; - if !!(v17 != 0) { + if !!(v8 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1550) - v23 = old1 + v12 = old1 goto _24 _24: - if v23&int32(MAYBE_WAITERS) != 0 { - v25 = f + 140 - v26 = int32(1) - v27 = int32(1) - if v27 != 0 { - v27 = int32(FUTEX_PRIVATE) + if v12&int32(MAYBE_WAITERS) != 0 { + v15 = f + 140 + v17 = int32(1) + v21 = int32(1) + if v21 != 0 { + v21 = int32(FUTEX_PRIVATE) } - if v26 < Int32FromInt32(0) { - v26 = int32(INT_MAX) + if v17 < Int32FromInt32(0) { + v17 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)|v27), int64(v26)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)), int64(v26)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v21), int64(v17)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v17)) != 0 } return c } @@ -137313,7 +137313,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -137336,9 +137336,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -137349,21 +137349,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -137400,13 +137400,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -137425,7 +137425,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*uint8)(unsafe.Pointer(s)) = uint8(0) return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -137443,8 +137443,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -137452,24 +137452,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = Uint8FromInt32(c) - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } @@ -137516,7 +137516,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -137606,22 +137606,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -137639,7 +137639,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -137649,11 +137649,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -137767,7 +137767,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137930,11 +137930,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -137948,8 +137948,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137961,10 +137961,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137976,9 +137976,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -138106,11 +138106,11 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v12, v18, v22, v24, v27, v28, v3, v8 int32 - var v1, v14, v15, v16, v17, v2, v21, v26, v7 uintptr + var old, old1, r, v, v10, v12, v18, v3, v8 int32 + var v1, v14, v2, v7 uintptr var v13 uint8 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v18, v2, v21, v22, v24, v26, v27, v28, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v18, v2, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) @@ -138150,59 +138150,59 @@ _11: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v13 = Uint8FromInt32(c) - v15 = f + 40 - v14 = *(*uintptr)(unsafe.Pointer(v15)) - *(*uintptr)(unsafe.Pointer(v15))++ - *(*uint8)(unsafe.Pointer(v14)) = v13 - v12 = Int32FromUint8(v13) + v2 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v13 + v3 = Int32FromUint8(v13) } else { - v12 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v12 - v16 = f + 140 + c = v3 + v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) for { - v21 = v16 + v7 = v1 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1563) - v22 = v + v8 = v goto _23 _23: - old1 = v22 + old1 = v8 goto _20 _20: ; - v17 = v16 + v2 = v1 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1563) - v18 = r & int32(0x20000000) + v3 = r & int32(0x20000000) goto _19 _19: ; - if !!(v18 != 0) { + if !!(v3 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1563) - v24 = old1 + v10 = old1 goto _25 _25: - if v24&int32(MAYBE_WAITERS) != 0 { - v26 = f + 140 - v27 = int32(1) - v28 = int32(1) - if v28 != 0 { - v28 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v14 = f + 140 + v12 = int32(1) + v18 = int32(1) + if v18 != 0 { + v18 = int32(FUTEX_PRIVATE) } - if v27 < Int32FromInt32(0) { - v27 = int32(INT_MAX) + if v12 < Int32FromInt32(0) { + v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)|v28), int64(v27)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)), int64(v27)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v18), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 } return c } @@ -138224,7 +138224,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -138282,7 +138282,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -138412,8 +138412,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -138437,8 +138437,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -138446,11 +138446,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138460,8 +138460,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138505,7 +138505,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -138572,8 +138572,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -138581,7 +138581,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -138601,9 +138601,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138680,10 +138680,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -138790,11 +138790,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var old, owner, r, tid, v, v1, v11, v4, v9 int32 + var old, owner, r, tid, v, v1, v4, v9 int32 var self Tpthread_t var v13, v6 bool var v2, v3, v8 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v11, v13, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, owner, r, self, tid, v, v1, v13, v2, v3, v4, v6, v8, v9 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -138802,7 +138802,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -138818,10 +138818,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { v8 = v2 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1602) - v9 = v + v4 = v goto _10 _10: - old = v9 + old = v4 goto _7 _7: ; @@ -138832,21 +138832,21 @@ func Xftrylockfile(tls *TLS, f uintptr) (r1 int32) { // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1602) - v4 = r & int32(0x20000000) + v1 = r & int32(0x20000000) goto _5 _5: } - if !(v6 && !(v4 != 0)) { + if !(v6 && !(v1 != 0)) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1602) - v11 = old + v9 = old goto _12 _12: } - if v13 || v11 != 0 { + if v13 || v9 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -138862,7 +138862,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -138871,9 +138871,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138896,11 +138896,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138948,15 +138948,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -139026,10 +139026,10 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v12, v17, v21, v23, v26, v27, v3, v8 int32 - var v1, v13, v14, v15, v16, v2, v20, v25, v7 uintptr + var c, old, old1, r, v, v10, v12, v17, v21, v3, v8 int32 + var v1, v13, v14, v15, v2, v7 uintptr var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v2, v20, v21, v23, v25, v26, v27, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v17, v2, v21, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) @@ -139068,58 +139068,58 @@ _11: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v12 = X__uflow(tls, f) + v3 = X__uflow(tls, f) } - c = v12 - v15 = f + 140 + c = v3 + v7 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) for { - v20 = v15 + v14 = v7 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1550) - v21 = v + v10 = v goto _22 _22: - old1 = v21 + old1 = v10 goto _19 _19: ; - v16 = v15 + v13 = v7 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1550) - v17 = r & int32(0x20000000) + v8 = r & int32(0x20000000) goto _18 _18: ; - if !!(v17 != 0) { + if !!(v8 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1550) - v23 = old1 + v12 = old1 goto _24 _24: - if v23&int32(MAYBE_WAITERS) != 0 { - v25 = f + 140 - v26 = int32(1) - v27 = int32(1) - if v27 != 0 { - v27 = int32(FUTEX_PRIVATE) + if v12&int32(MAYBE_WAITERS) != 0 { + v15 = f + 140 + v17 = int32(1) + v21 = int32(1) + if v21 != 0 { + v21 = int32(FUTEX_PRIVATE) } - if v26 < Int32FromInt32(0) { - v26 = int32(INT_MAX) + if v17 < Int32FromInt32(0) { + v17 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)|v27), int64(v26)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)), int64(v26)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v21), int64(v17)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v17)) != 0 } return c } @@ -139138,7 +139138,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139171,7 +139171,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -139196,10 +139196,10 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r1 int32) { - var c, old, old1, r, v, v10, v12, v17, v21, v23, v26, v27, v3, v8 int32 - var v1, v13, v14, v15, v16, v2, v20, v25, v7 uintptr + var c, old, old1, r, v, v10, v12, v17, v21, v3, v8 int32 + var v1, v13, v14, v15, v2, v7 uintptr var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v2, v20, v21, v23, v25, v26, v27, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, r, v, v1, v10, v12, v13, v14, v15, v17, v2, v21, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) @@ -139238,58 +139238,58 @@ _11: ___lockfile(tls, f) } if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) } else { - v12 = X__uflow(tls, f) + v3 = X__uflow(tls, f) } - c = v12 - v15 = f + 140 + c = v3 + v7 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1550) for { - v20 = v15 + v14 = v7 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1550) - v21 = v + v10 = v goto _22 _22: - old1 = v21 + old1 = v10 goto _19 _19: ; - v16 = v15 + v13 = v7 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1550) - v17 = r & int32(0x20000000) + v8 = r & int32(0x20000000) goto _18 _18: ; - if !!(v17 != 0) { + if !!(v8 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1550) - v23 = old1 + v12 = old1 goto _24 _24: - if v23&int32(MAYBE_WAITERS) != 0 { - v25 = f + 140 - v26 = int32(1) - v27 = int32(1) - if v27 != 0 { - v27 = int32(FUTEX_PRIVATE) + if v12&int32(MAYBE_WAITERS) != 0 { + v15 = f + 140 + v17 = int32(1) + v21 = int32(1) + if v21 != 0 { + v21 = int32(FUTEX_PRIVATE) } - if v26 < Int32FromInt32(0) { - v26 = int32(INT_MAX) + if v17 < Int32FromInt32(0) { + v17 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)|v27), int64(v26)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v25), int64(Int32FromInt32(FUTEX_WAKE)), int64(v26)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v21), int64(v17)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v17)) != 0 } return c } @@ -139308,7 +139308,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -139333,7 +139333,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139346,12 +139346,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 uint8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -139387,7 +139387,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -139414,7 +139414,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -139422,14 +139422,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -139441,14 +139441,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break @@ -139500,7 +139500,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -139511,7 +139511,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) } *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) @@ -139690,17 +139690,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139716,9 +139716,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*uint8)(unsafe.Pointer(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139834,17 +139834,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139860,9 +139860,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139953,11 +139953,11 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v12, v18, v22, v24, v27, v28, v3, v8 int32 - var v1, v14, v15, v16, v17, v2, v21, v26, v7 uintptr + var old, old1, r, v, v10, v12, v18, v3, v8 int32 + var v1, v14, v2, v7 uintptr var v13 uint8 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v18, v2, v21, v22, v24, v26, v27, v28, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v18, v2, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) @@ -139997,59 +139997,59 @@ _11: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v13 = Uint8FromInt32(c) - v15 = f + 40 - v14 = *(*uintptr)(unsafe.Pointer(v15)) - *(*uintptr)(unsafe.Pointer(v15))++ - *(*uint8)(unsafe.Pointer(v14)) = v13 - v12 = Int32FromUint8(v13) + v2 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v13 + v3 = Int32FromUint8(v13) } else { - v12 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v12 - v16 = f + 140 + c = v3 + v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) for { - v21 = v16 + v7 = v1 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1563) - v22 = v + v8 = v goto _23 _23: - old1 = v22 + old1 = v8 goto _20 _20: ; - v17 = v16 + v2 = v1 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1563) - v18 = r & int32(0x20000000) + v3 = r & int32(0x20000000) goto _19 _19: ; - if !!(v18 != 0) { + if !!(v3 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1563) - v24 = old1 + v10 = old1 goto _25 _25: - if v24&int32(MAYBE_WAITERS) != 0 { - v26 = f + 140 - v27 = int32(1) - v28 = int32(1) - if v28 != 0 { - v28 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v14 = f + 140 + v12 = int32(1) + v18 = int32(1) + if v18 != 0 { + v18 = int32(FUTEX_PRIVATE) } - if v27 < Int32FromInt32(0) { - v27 = int32(INT_MAX) + if v12 < Int32FromInt32(0) { + v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)|v28), int64(v27)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)), int64(v27)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v18), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 } return c } @@ -140071,7 +140071,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -140107,7 +140107,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -140133,11 +140133,11 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r1 int32) { - var old, old1, r, v, v10, v12, v18, v22, v24, v27, v28, v3, v8 int32 - var v1, v14, v15, v16, v17, v2, v21, v26, v7 uintptr + var old, old1, r, v, v10, v12, v18, v3, v8 int32 + var v1, v14, v2, v7 uintptr var v13 uint8 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v15, v16, v17, v18, v2, v21, v22, v24, v26, v27, v28, v3, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v, v1, v10, v12, v13, v14, v18, v2, v3, v5, v7, v8 v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) @@ -140177,59 +140177,59 @@ _11: } if Int32FromUint8(Uint8FromInt32(c)) != (*TFILE)(unsafe.Pointer(f)).Flbf && (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwend { v13 = Uint8FromInt32(c) - v15 = f + 40 - v14 = *(*uintptr)(unsafe.Pointer(v15)) - *(*uintptr)(unsafe.Pointer(v15))++ - *(*uint8)(unsafe.Pointer(v14)) = v13 - v12 = Int32FromUint8(v13) + v2 = f + 40 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = v13 + v3 = Int32FromUint8(v13) } else { - v12 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v12 - v16 = f + 140 + c = v3 + v1 = f + 140 // __asm__ __volatile__ ("sync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 40, __ccgo_ts+1563) for { - v21 = v16 + v7 = v1 // __asm__ __volatile__ ("lwarx %0, 0, %2" : "=r"(v) : "m"(*p), "r"(p)); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 5, __ccgo_ts+1563) - v22 = v + v8 = v goto _23 _23: - old1 = v22 + old1 = v8 goto _20 _20: ; - v17 = v16 + v2 = v1 // __asm__ __volatile__ ( // // "stwcx. %2, 0, %3 ; mfcr %0" // : "=r"(r), "=m"(*p) : "r"(v), "r"(p) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 13, __ccgo_ts+1563) - v18 = r & int32(0x20000000) + v3 = r & int32(0x20000000) goto _19 _19: ; - if !!(v18 != 0) { + if !!(v3 != 0) { break } } // __asm__ __volatile__ ("isync" : : : "memory"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 48, __ccgo_ts+1563) - v24 = old1 + v10 = old1 goto _25 _25: - if v24&int32(MAYBE_WAITERS) != 0 { - v26 = f + 140 - v27 = int32(1) - v28 = int32(1) - if v28 != 0 { - v28 = int32(FUTEX_PRIVATE) + if v10&int32(MAYBE_WAITERS) != 0 { + v14 = f + 140 + v12 = int32(1) + v18 = int32(1) + if v18 != 0 { + v18 = int32(FUTEX_PRIVATE) } - if v27 < Int32FromInt32(0) { - v27 = int32(INT_MAX) + if v12 < Int32FromInt32(0) { + v12 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)|v28), int64(v27)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v26), int64(Int32FromInt32(FUTEX_WAKE)), int64(v27)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v18), int64(v12)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v12)) != 0 } return c } @@ -140251,7 +140251,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -140279,7 +140279,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -140309,7 +140309,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -140645,7 +140645,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140680,7 +140680,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140716,7 +140716,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140750,7 +140750,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -140767,12 +140767,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -140789,10 +140789,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140801,13 +140801,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -141083,7 +141083,7 @@ func _pad3(tls *TLS, f uintptr, c uint8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -141097,13 +141097,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -141115,45 +141115,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -141168,13 +141168,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]uint8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -141183,7 +141183,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]uint8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1628 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -141196,21 +141196,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*uint8)(unsafe.Pointer(v10)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v11)) = Uint8FromInt32(v12) - estr-- - v13 = estr - *(*uint8)(unsafe.Pointer(v13)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*uint8)(unsafe.Pointer(v15)) = uint8('.') + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -141322,46 +141322,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -141377,22 +141377,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -141411,21 +141411,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -141437,8 +141437,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -141448,10 +141448,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -141459,15 +141459,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -141479,23 +141479,23 @@ _4: } } if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -141506,8 +141506,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -141526,14 +141526,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -141547,8 +141547,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -141572,21 +141572,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -141599,31 +141599,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*uint8)(unsafe.Pointer(v43)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v44)) = Uint8FromInt32(v45) - estr-- - v46 = estr - *(*uint8)(unsafe.Pointer(v46)) = Uint8FromInt32(t) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -141647,15 +141647,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*uint8)(unsafe.Pointer(v48)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*uint8)(unsafe.Pointer(v49)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -141673,21 +141673,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*uint8)(unsafe.Pointer(v51)) = uint8('0') + s3 = s3 - 1 + v5 = s3 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, uint8('0'), p+int32(9), int32(9), 0) } else { @@ -141701,30 +141701,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*uint8)(unsafe.Pointer(v54)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*uint8)(unsafe.Pointer(v55)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+606, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -141736,11 +141736,11 @@ _4: } _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -141759,7 +141759,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -141767,19 +141767,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]uint8 var _ /* mb at bp+48 */ [4]uint8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -141792,7 +141792,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -141805,7 +141805,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -141815,8 +141815,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -141831,10 +141831,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -141842,11 +141842,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -141858,7 +141858,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -141867,19 +141867,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -141892,16 +141892,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -141909,7 +141909,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141925,7 +141925,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -141964,11 +141964,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -142044,14 +142044,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -142077,10 +142077,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -142095,7 +142095,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -142113,12 +142113,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*uint8)(unsafe.Pointer(v35)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -142132,24 +142132,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1669 + v8 = __ccgo_ts + 1669 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -142163,23 +142163,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -142192,28 +142192,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -142278,7 +142278,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142287,7 +142287,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -142313,12 +142313,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -142357,11 +142357,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -142415,7 +142415,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142429,17 +142429,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -142462,99 +142462,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -142565,33 +142565,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -142645,14 +142645,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -142670,85 +142670,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -142762,10 +142762,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -142773,11 +142773,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -142789,36 +142789,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -142831,16 +142831,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142851,12 +142851,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -142875,23 +142875,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v73))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -142900,40 +142900,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v79))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142941,7 +142941,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142964,26 +142964,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142998,15 +142998,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -143015,6 +143007,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -143030,20 +143030,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -143055,7 +143055,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143064,7 +143064,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143236,7 +143236,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -143293,7 +143293,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -143301,7 +143301,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]uint8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -143314,7 +143314,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -143338,7 +143338,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -143353,7 +143353,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -143364,7 +143364,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) goto _4 _4: ; @@ -143376,7 +143376,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -143391,13 +143391,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -143406,16 +143406,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -143471,7 +143471,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -143513,11 +143513,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -143538,27 +143538,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1669 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -143573,13 +143573,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -143631,7 +143631,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -143640,7 +143640,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -143732,7 +143732,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -143775,7 +143775,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -143796,14 +143796,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -143828,23 +143828,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143855,37 +143855,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143894,7 +143894,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -143904,7 +143904,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -143915,8 +143915,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -143929,9 +143929,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -144003,45 +144003,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -144068,8 +144068,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -144088,17 +144088,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -144106,11 +144106,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -144125,27 +144125,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -144155,17 +144155,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -144174,16 +144174,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -144241,23 +144241,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1712, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1730, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -144265,7 +144265,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -144277,7 +144277,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -144286,7 +144286,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -144367,8 +144367,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -144382,11 +144382,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -144507,11 +144507,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -144529,9 +144529,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -144545,9 +144545,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -144592,9 +144592,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -144612,10 +144612,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -144734,9 +144734,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144747,27 +144747,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -144789,19 +144789,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144831,19 +144831,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144868,11 +144868,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -144899,9 +144899,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]uint8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -144918,9 +144918,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -145105,9 +145105,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -145116,7 +145116,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -145127,7 +145127,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -145139,10 +145139,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -145153,16 +145153,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -145193,12 +145193,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -145245,13 +145245,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -145267,17 +145267,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -145285,7 +145285,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -145316,9 +145316,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -145328,11 +145328,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145505,7 +145505,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145513,7 +145513,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -145524,11 +145524,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145549,11 +145549,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145609,7 +145609,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145617,7 +145617,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -145628,11 +145628,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145653,11 +145653,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145767,9 +145767,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -145785,9 +145785,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -145803,7 +145803,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145811,19 +145811,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145862,8 +145862,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -145876,7 +145876,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -145887,8 +145887,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -145915,9 +145915,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -145935,9 +145935,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -145945,14 +145945,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -145966,32 +145966,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -146002,22 +146002,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -146033,23 +146033,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -146065,18 +146065,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -146092,170 +146092,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -146265,27 +146265,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146427,29 +146427,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146484,22 +146484,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146507,10 +146507,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -146523,12 +146523,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -146558,7 +146558,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -146583,9 +146583,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -146598,14 +146598,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } for { @@ -146616,42 +146616,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } } @@ -146678,7 +146678,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -146736,9 +146736,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -146769,8 +146769,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -146786,8 +146786,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -146817,8 +146817,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 uint8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 uint8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -146832,8 +146832,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -146854,16 +146854,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -146902,9 +146902,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -146917,9 +146917,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { goto tail @@ -146934,7 +146934,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146942,19 +146942,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -146996,8 +146996,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -147036,7 +147036,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -147099,7 +147099,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -147120,7 +147120,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -147154,8 +147154,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -147176,10 +147176,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) @@ -147187,16 +147187,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -147205,7 +147205,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -147287,12 +147287,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 uint8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 uint8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -147308,9 +147308,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { wd = d @@ -147323,7 +147323,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -147332,19 +147332,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*uint8)(unsafe.Pointer(d)) = uint8(0) goto finish @@ -147383,7 +147383,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -147403,7 +147403,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -147419,7 +147419,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147430,9 +147430,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -147458,21 +147458,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + v1 = d + d = d + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) return a } @@ -147487,7 +147487,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147498,9 +147498,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -147556,7 +147556,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*uint8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147587,7 +147587,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { end = uintptr(0) @@ -147613,7 +147613,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -147624,12 +147624,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -147641,10 +147641,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*uint8)(unsafe.Pointer(c)) != 0) { @@ -147658,22 +147658,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -147682,18 +147682,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147825,29 +147825,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147884,7 +147884,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -147894,22 +147894,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -147917,10 +147917,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -147933,12 +147933,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -147986,9 +147986,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -147996,17 +147996,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v1 = _p2 + _p2 = _p2 + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -148020,9 +148020,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -148030,18 +148030,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -148084,7 +148084,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -148100,7 +148100,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -148129,12 +148129,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -148334,7 +148334,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -148347,7 +148347,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -148365,21 +148365,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -148397,7 +148397,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148423,7 +148423,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -148455,7 +148455,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -148510,10 +148510,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -148523,7 +148523,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -148537,23 +148537,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -148562,29 +148562,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -148621,16 +148621,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -148638,10 +148638,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -148654,12 +148654,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -148695,9 +148695,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -148705,18 +148705,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -148745,7 +148745,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -148770,7 +148770,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148798,7 +148798,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148817,8 +148817,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -148826,7 +148826,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148834,9 +148834,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -148860,7 +148860,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148893,7 +148893,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148918,27 +148918,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1772, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -149001,7 +149001,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -149212,7 +149212,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -149263,38 +149263,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -149302,15 +149302,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(Int32FromUint8(_days_in_month[months]) <= remdays) { break } - remdays -= Int32FromUint8(_days_in_month[months]) + remdays = remdays - Int32FromUint8(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -149356,19 +149356,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -149405,7 +149405,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -149415,20 +149415,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -149447,21 +149447,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -149472,7 +149472,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -149484,10 +149484,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -149501,7 +149501,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -149527,13 +149527,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -149543,13 +149543,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]uint8 var _ /* dummy_name at bp+308 */ [7]uint8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1779) @@ -149573,7 +149573,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -149587,7 +149587,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -149612,7 +149612,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1782) != 0) { @@ -149634,7 +149634,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -149661,7 +149661,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -149678,16 +149678,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -149707,7 +149707,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -149742,11 +149742,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149784,10 +149784,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -149816,7 +149816,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -149867,25 +149867,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -149928,16 +149928,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -150010,7 +150010,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -150027,8 +150027,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -150038,15 +150038,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -150056,11 +150056,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -150457,9 +150457,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -150487,9 +150487,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -150500,7 +150500,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -150509,7 +150509,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -150533,10 +150533,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1704 width = int32(2) def_pad = int32('0') @@ -150590,14 +150590,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -150614,7 +150614,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -150645,11 +150645,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -150658,14 +150658,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -150689,11 +150689,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -150753,11 +150753,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1908, VaList(bp+8, val))) case int32('_'): @@ -150799,15 +150799,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]uint8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -150819,21 +150819,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -150850,7 +150850,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -150861,8 +150861,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -150871,8 +150871,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -150885,50 +150885,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v7))) = uint8('-') - width-- + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v10))) = uint8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v12))) = uint8('0') + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -150962,15 +150962,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -150994,21 +150994,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -151018,7 +151018,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -151115,7 +151115,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -151170,19 +151170,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*uint8)(unsafe.Pointer(s)) != 0; v48 { - v45 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -151194,7 +151194,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -151202,7 +151202,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -151266,7 +151266,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -151279,9 +151279,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -151300,13 +151300,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -151321,30 +151321,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -151364,13 +151364,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -151569,7 +151569,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -151577,7 +151577,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -151589,7 +151589,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -151635,40 +151635,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151821,8 +151821,8 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { trc("tls=%v old=%v new1=%v flags=%v, (%v:)", tls, old, new1, flags, origin(2)) defer func() { trc("-> %v", r1) }() } - var r, v1, v2 int32 - _, _, _ = r, v1, v2 + var r, v1 int32 + _, _ = r, v1 if old == new1 { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } @@ -151842,9 +151842,9 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) - r = v2 - if !(v2 == -int32(EBUSY)) { + v1 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) + r = v1 + if !(v1 == -int32(EBUSY)) { break } } @@ -152076,7 +152076,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) @@ -152239,7 +152239,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_riscv64.go b/vendor/modernc.org/libc/ccgo_linux_riscv64.go index 5d28c7f..2793f3a 100644 --- a/vendor/modernc.org/libc/ccgo_linux_riscv64.go +++ b/vendor/modernc.org/libc/ccgo_linux_riscv64.go @@ -583,14 +583,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -599,8 +599,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -931,18 +931,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -974,9 +974,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -1026,9 +1026,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1072,18 +1072,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1091,18 +1091,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1161,8 +1161,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1183,42 +1183,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1232,11 +1232,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1246,17 +1246,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1267,11 +1267,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1284,17 +1284,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1307,11 +1307,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1323,8 +1323,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1340,92 +1340,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1458,14 +1458,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1479,32 +1479,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1523,11 +1523,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1542,12 +1542,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1559,32 +1559,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1603,11 +1603,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1874,18 +1874,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1893,18 +1893,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1917,8 +1917,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1939,42 +1939,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1988,11 +1988,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -2001,17 +2001,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -2022,11 +2022,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2041,17 +2041,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2064,11 +2064,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2080,8 +2080,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2097,92 +2097,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2226,13 +2226,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2247,29 +2247,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2300,8 +2300,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2309,22 +2309,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2346,13 +2346,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2367,29 +2367,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2397,21 +2397,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2425,18 +2425,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2459,18 +2459,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2478,18 +2478,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2500,15 +2500,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2551,15 +2551,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2602,11 +2602,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2616,15 +2616,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2649,50 +2649,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7344,13 +7344,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7406,14 +7406,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7428,14 +7428,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= X__libc.Fpage_size + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / X__libc.Fpage_size if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7444,7 +7444,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -8820,16 +8820,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8838,10 +8838,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8850,16 +8850,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8868,16 +8868,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8886,58 +8886,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -8957,7 +8957,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -8968,12 +8968,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -8981,36 +8981,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9018,9 +9018,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9029,10 +9029,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9079,9 +9079,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9098,25 +9098,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9127,11 +9127,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9156,7 +9156,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9169,7 +9169,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9186,13 +9186,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9205,7 +9205,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9230,7 +9230,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9238,7 +9238,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9257,9 +9257,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9268,7 +9268,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] @@ -11151,7 +11151,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11178,14 +11178,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11195,8 +11195,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11231,35 +11231,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11272,10 +11272,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11289,19 +11289,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11312,7 +11312,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11328,10 +11328,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11340,7 +11340,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11350,23 +11350,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11397,12 +11397,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11412,10 +11412,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11435,11 +11435,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11454,11 +11454,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11470,12 +11470,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11684,7 +11684,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11692,60 +11692,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11758,7 +11758,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -11802,7 +11802,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -11819,8 +11819,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -11831,8 +11831,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -11872,15 +11872,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -11911,7 +11911,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -11950,7 +11950,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -11980,13 +11980,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v5)) = uint8('$') i = uint32(0) for { @@ -11997,7 +11997,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -12197,7 +12197,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12207,7 +12207,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12235,7 +12235,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12252,7 +12252,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12300,7 +12300,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12317,8 +12317,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12329,8 +12329,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12342,15 +12342,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12374,7 +12374,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12417,7 +12417,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12450,7 +12450,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12477,7 +12477,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12491,7 +12491,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12505,7 +12505,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12535,11 +12535,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12549,7 +12549,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -12859,7 +12859,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12876,8 +12876,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -12888,8 +12888,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -12901,15 +12901,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12933,7 +12933,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -12961,7 +12961,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -12986,7 +12986,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13019,7 +13019,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13046,7 +13046,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13060,7 +13060,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13074,7 +13074,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13104,11 +13104,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13118,7 +13118,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -13266,9 +13266,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13280,18 +13280,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17410,8 +17410,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22128,7 +22128,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22167,10 +22167,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22236,15 +22236,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22255,15 +22255,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -24820,10 +24820,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -24858,16 +24858,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -24937,7 +24937,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25056,7 +25056,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25158,7 +25158,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25170,7 +25170,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25615,7 +25615,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25639,7 +25639,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25683,7 +25683,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -25862,15 +25862,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -25879,23 +25879,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -25905,18 +25905,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -25924,58 +25924,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26000,7 +26000,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26010,32 +26010,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26051,7 +26051,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26060,15 +26060,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26079,14 +26079,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26096,7 +26096,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26104,11 +26104,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26140,12 +26140,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26170,19 +26170,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26195,24 +26195,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26273,7 +26273,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26284,11 +26284,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26300,29 +26300,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26335,40 +26335,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26395,11 +26395,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26413,7 +26413,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26429,26 +26429,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26460,15 +26460,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26492,41 +26492,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26538,15 +26538,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26556,10 +26556,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26573,13 +26573,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26591,11 +26591,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26607,10 +26607,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26629,7 +26629,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26645,16 +26645,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -26663,24 +26663,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -26688,12 +26688,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -26707,55 +26707,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -26763,26 +26763,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26790,19 +26790,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27076,11 +27076,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27091,7 +27091,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27109,42 +27109,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27163,7 +27163,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27177,18 +27177,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27196,18 +27196,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27221,18 +27221,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27355,7 +27355,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') @@ -27370,21 +27370,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27427,7 +27427,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -27543,7 +27543,7 @@ type TVerdaux = struct { func _checkver(tls *TLS, def uintptr, vsym int32, vername uintptr, strings uintptr) (r int32) { var aux uintptr _ = aux - vsym &= int32(0x7fff) + vsym = vsym & int32(0x7fff) for { if !(Int32FromUint16((*TVerdef)(unsafe.Pointer(def)).Fvd_flags)&Int32FromInt32(VER_FLG_BASE) != 0) && Int32FromUint16((*TVerdef)(unsafe.Pointer(def)).Fvd_ndx)&int32(0x7fff) == vsym { break @@ -27578,7 +27578,7 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { goto _1 _1: ; - i += uint64(2) + i = i + uint64(2) } if !(*(*Tsize_t)(unsafe.Pointer(X__libc.Fauxv + uintptr(i+uint64(1))*8)) != 0) { return uintptr(0) @@ -27602,7 +27602,7 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { goto _2 _2: ; - i++ + i = i + 1 ph = ph + uintptr((*TEhdr)(unsafe.Pointer(eh)).Fe_phentsize) } if !(dynv != 0) || base == Uint64FromInt32(-Int32FromInt32(1)) { @@ -27635,7 +27635,7 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { goto _3 _3: ; - i += uint64(2) + i = i + uint64(2) } if !(strings != 0) || !(syms != 0) || !(hashtab != 0) { return uintptr(0) @@ -27667,7 +27667,7 @@ func X__vdsosym(tls *TLS, vername uintptr, name uintptr) (r uintptr) { goto _4 _4: ; - i++ + i = i + 1 } return uintptr(0) } @@ -28340,7 +28340,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28547,7 +28547,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && Int32FromUint8(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = uint8(0) } @@ -29040,7 +29040,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -29067,9 +29067,9 @@ const VDSO_FLUSH_ICACHE_SYM = "__vdso_flush_icache" const VDSO_FLUSH_ICACHE_VER = "LINUX_4.15" func _flush_icache_init(tls *TLS, start uintptr, end uintptr, flags uint64) (r int32) { - var f, old, p1 uintptr - var tmp, v2 int32 - _, _, _, _, _ = f, old, p1, tmp, v2 + var f, p1 uintptr + var v2 int32 + _, _, _ = f, p1, v2 p1 = X__vdsosym(tls, __ccgo_ts+322, __ccgo_ts+333) f = p1 // __asm__ __volatile__ ( @@ -29079,7 +29079,7 @@ func _flush_icache_init(tls *TLS, start uintptr, end uintptr, flags uint64) (r i // : "r"(p), "r"(t), "r"(s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 28, __ccgo_ts+402) - _ = old + goto _1 _1: ; @@ -30269,7 +30269,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31180,8 +31180,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31201,10 +31201,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31293,10 +31293,10 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r bp := tls.Alloc(16) defer tls.Free(16) var map1, msg, msgs, set, sets, strings uintptr - var nmsgs, nsets, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 Tuint32_t + var nmsgs, nsets, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 Tuint32_t var _ /* msg_id_be at bp+4 */ Tuint32_t var _ /* set_id_be at bp+0 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v16, v17, v19, v2, v20, v22, v23, v4, v5, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = map1, msg, msgs, nmsgs, nsets, set, sets, strings, v1, v10, v11, v13, v14, v2, v4, v5, v7, v8 map1 = catd v1 = *(*Tuint32_t)(unsafe.Pointer(map1 + UintptrFromInt32(4))) v2 = v1>>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v16>>int32(8)&uint32(0xff00) | v16<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<>int32(24) | v19>>int32(8)&uint32(0xff00) | v19<>int32(24) | v4>>int32(8)&uint32(0xff00) | v4<>int32(24) | v22>>int32(8)&uint32(0xff00) | v22<>int32(24) | v1>>int32(8)&uint32(0xff00) | v1<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98169,7 +98169,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98177,8 +98177,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98202,16 +98202,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98278,23 +98278,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98335,10 +98335,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98356,10 +98356,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98369,7 +98369,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]uint8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98557,11 +98557,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98574,7 +98574,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98583,27 +98583,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98629,11 +98629,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98692,8 +98692,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98706,7 +98706,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -98730,7 +98730,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -98755,13 +98755,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -98779,17 +98779,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98798,9 +98798,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -98817,18 +98817,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -98900,7 +98900,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -98918,17 +98918,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -99019,7 +99019,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -99039,7 +99039,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*uint8)(unsafe.Pointer(v54)) = uint8(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -99057,7 +99057,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -99066,17 +99066,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99088,24 +99088,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v57)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v60)) = uint8(v62) + *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99114,7 +99114,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99124,14 +99124,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*uint8)(unsafe.Pointer(v63)) = uint8(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*uint8)(unsafe.Pointer(v65)) = uint8(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99143,56 +99143,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*uint8)(unsafe.Pointer(v67)) = uint8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*uint8)(unsafe.Pointer(v69)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*uint8)(unsafe.Pointer(v71)) = uint8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*uint8)(unsafe.Pointer(v73)) = uint8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*uint8)(unsafe.Pointer(v75)) = uint8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*uint8)(unsafe.Pointer(v77)) = uint8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*uint8)(unsafe.Pointer(v79)) = uint8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*uint8)(unsafe.Pointer(v81)) = uint8(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*uint8)(unsafe.Pointer(v83)) = uint8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*uint8)(unsafe.Pointer(v85)) = uint8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*uint8)(unsafe.Pointer(v87)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99203,38 +99203,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*uint8)(unsafe.Pointer(v89)) = uint8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*uint8)(unsafe.Pointer(v91)) = uint8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*uint8)(unsafe.Pointer(v93)) = uint8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*uint8)(unsafe.Pointer(v95)) = uint8(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*uint8)(unsafe.Pointer(v97)) = uint8(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*uint8)(unsafe.Pointer(v99)) = uint8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*uint8)(unsafe.Pointer(v101)) = uint8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*uint8)(unsafe.Pointer(v103)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99265,7 +99265,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99342,8 +99342,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99357,11 +99357,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 571 + v1 = __ccgo_ts + 571 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99398,13 +99398,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99473,11 +99473,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]uint8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*uint8)(unsafe.Pointer(val)) != 0) { @@ -99506,7 +99506,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 580 @@ -99574,11 +99574,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99682,7 +99682,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99710,7 +99710,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -99787,7 +99787,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -99798,7 +99798,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99908,7 +99908,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -99922,7 +99922,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -99966,7 +99966,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -100022,10 +100022,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]uint8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -100061,7 +100061,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100074,7 +100074,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -100085,22 +100085,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + s = s - 1 + v3 = s + *(*uint8)(unsafe.Pointer(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100113,11 +100113,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 571 + v3 = __ccgo_ts + 571 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100151,9 +100151,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100167,15 +100167,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100187,9 +100187,9 @@ _4: for { switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100210,7 +100210,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100221,13 +100221,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100236,12 +100236,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100250,12 +100250,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100266,8 +100266,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100462,9 +100462,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100477,11 +100477,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100681,12 +100681,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100706,11 +100706,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101091,12 +101091,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101221,10 +101221,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101252,8 +101252,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101267,17 +101267,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101297,18 +101297,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101321,7 +101321,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101340,7 +101340,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101354,7 +101354,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101366,11 +101366,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101381,7 +101381,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101395,37 +101395,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101439,11 +101439,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101457,17 +101457,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101489,18 +101489,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101512,38 +101512,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101559,7 +101559,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101575,7 +101575,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101583,11 +101583,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101653,13 +101653,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -101816,12 +101816,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -101863,11 +101863,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102519,11 +102519,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102538,14 +102538,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102623,11 +102623,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -102740,11 +102740,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -102880,11 +102880,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = _atanhi1[id] - (float32(x3*(s1+s2)) - _atanlo1[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } // C documentation @@ -103048,12 +103048,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103091,8 +103091,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103343,7 +103343,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103352,7 +103352,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103369,10 +103369,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103492,12 +103492,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103533,11 +103533,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -103811,7 +103811,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -103846,12 +103846,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -103878,11 +103878,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -103996,7 +103996,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -104031,12 +104031,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -104063,11 +104063,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104103,11 +104103,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104194,13 +104194,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104393,11 +104393,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104473,14 +104473,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104488,13 +104488,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104548,9 +104548,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104575,13 +104575,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104680,13 +104680,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -104821,7 +104821,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -104899,7 +104899,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -104956,7 +104956,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return x3 - (float32(x3*e) - hxs) } e = float32(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Float32FromFloat32(0.5)*(x3-e)) - Float32FromFloat32(0.5) @@ -105002,12 +105002,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105016,8 +105016,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -105059,13 +105059,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105074,10 +105074,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105095,13 +105095,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105110,10 +105110,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105329,7 +105329,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105341,10 +105341,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105457,7 +105457,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) @@ -105467,24 +105467,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _3 @@ -105494,38 +105494,38 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>Int32FromInt32(32) != 0 { - y = uint32(v4 >> int32(32)) + v1 = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + if v1>>Int32FromInt32(32) != 0 { + y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) } else { - y = uint32(v4) + y = uint32(v1) r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } - v5 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) + v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _6 _6: - d = v5 - int32(1) + d = v2 - int32(1) if d < 0 { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105536,7 +105536,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { return float64(x1*y1) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105569,7 +105569,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) - r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) + r1 = r1 + float64(Tdouble_t(tiny*tiny)*(r1-r1)) } } else { /* only round once when scaled */ @@ -105602,13 +105602,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105617,27 +105617,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105645,11 +105645,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105659,13 +105659,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105674,27 +105674,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105702,11 +105702,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105724,13 +105724,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105739,27 +105739,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105767,11 +105767,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -105781,13 +105781,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105796,27 +105796,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -105824,11 +105824,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -105850,7 +105850,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -105863,7 +105863,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105911,13 +105911,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -105970,17 +105970,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106111,17 +106111,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106142,12 +106142,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106171,10 +106171,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106186,12 +106186,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106215,10 +106215,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106255,7 +106255,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106268,7 +106268,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106286,10 +106286,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106329,13 +106329,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106410,13 +106410,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float32FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106479,8 +106479,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106531,7 +106531,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106553,8 +106553,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106650,7 +106650,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -106806,7 +106806,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -106914,7 +106914,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -106994,7 +106994,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107139,7 +107139,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107247,7 +107247,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107338,7 +107338,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107485,7 +107485,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107592,7 +107592,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107674,7 +107674,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107816,7 +107816,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -107923,7 +107923,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -107963,7 +107963,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -107977,14 +107977,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -108027,7 +108027,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -108051,12 +108051,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -108069,8 +108069,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108085,7 +108085,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108110,7 +108110,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108123,14 +108123,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108157,15 +108157,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108231,7 +108231,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108241,11 +108241,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108259,7 +108259,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108270,14 +108270,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108291,7 +108291,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108314,12 +108314,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108331,8 +108331,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108347,7 +108347,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108372,7 +108372,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108385,14 +108385,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108418,13 +108418,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108461,7 +108461,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108470,11 +108470,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108583,8 +108583,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108690,7 +108690,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108698,11 +108698,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108714,20 +108714,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -108841,7 +108841,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -108947,7 +108947,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -108955,11 +108955,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -108971,20 +108971,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109127,9 +109127,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109155,31 +109155,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109279,8 +109279,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109475,7 +109475,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109485,7 +109485,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109575,7 +109575,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109585,7 +109585,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = v1 - c /= *(*float32)(unsafe.Pointer(bp)) + c = c / *(*float32)(unsafe.Pointer(bp)) } else { c = Float32FromInt32(0) } @@ -109634,9 +109634,9 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109659,31 +109659,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110302,9 +110302,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110402,9 +110402,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110461,8 +110461,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110476,7 +110476,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110505,32 +110505,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110660,12 +110660,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110752,16 +110752,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -110831,11 +110831,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, x2 Tdouble_t var ix, iy Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -110854,19 +110854,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -110880,14 +110880,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -110899,43 +110899,43 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111367,8 +111367,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111376,10 +111376,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111387,10 +111387,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111474,13 +111474,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111538,8 +111538,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111547,10 +111547,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111558,10 +111558,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111836,13 +111836,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -111858,10 +111858,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -111887,13 +111887,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -111909,10 +111909,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -111984,11 +111984,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -111997,11 +111997,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -112028,22 +112028,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = x if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float32FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float32FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112089,12 +112089,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112109,18 +112109,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112152,14 +112152,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112175,18 +112175,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112199,9 +112199,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112247,13 +112247,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112269,18 +112269,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112311,11 +112311,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112331,24 +112331,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112409,13 +112409,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112429,18 +112429,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112471,11 +112471,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112645,9 +112645,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112666,7 +112666,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112675,7 +112675,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112703,9 +112703,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -112815,7 +112815,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -112850,9 +112850,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -112862,13 +112862,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -112894,11 +112894,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -112913,18 +112913,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112960,13 +112960,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112980,18 +112980,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -113008,28 +113008,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113227,8 +113227,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113328,7 +113328,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113341,7 +113341,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113411,7 +113411,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113424,10 +113424,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113438,7 +113438,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113585,12 +113585,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*uint8)(unsafe.Pointer(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) @@ -113641,7 +113641,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113650,7 +113650,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113684,7 +113684,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113696,7 +113696,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113708,7 +113708,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) return s @@ -113792,7 +113792,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -113807,11 +113807,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -113904,17 +113904,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114191,11 +114191,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114247,7 +114247,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114276,7 +114276,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114293,7 +114293,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114301,9 +114301,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114318,11 +114318,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114333,11 +114333,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114354,22 +114354,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114395,7 +114395,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+759, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114411,13 +114411,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 828 + v5 = __ccgo_ts + 828 } else { - v6 = __ccgo_ts + 735 + v5 = __ccgo_ts + 735 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114478,9 +114478,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint64 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall4(tls, int64(SYS_prlimit64), int64(Int32FromInt32(0)), int64(resource), int64(Int32FromInt32(0)), int64(rlim))))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114503,11 +114503,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114559,7 +114559,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114584,7 +114584,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -114872,15 +114872,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -114890,12 +114890,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -114943,7 +114943,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -115086,28 +115086,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*uint8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115117,29 +115117,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*uint8)(unsafe.Pointer(v7)) = cval + v1 = dest + dest = dest + 1 + *(*uint8)(unsafe.Pointer(v1)) = cval src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } } *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -115188,7 +115188,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+864, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115246,15 +115246,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(176) defer tls.Free(176) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+160 */ TFTW var _ /* new at bp+128 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115306,11 +115306,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 128))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 128))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 128))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 160))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 128))).Flevel if h != 0 { @@ -115324,7 +115324,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115333,7 +115333,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 160))).Fbase = Int32FromUint64(k) } @@ -115348,10 +115348,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115389,9 +115389,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+128) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115403,11 +115403,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+160) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115580,7 +115580,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115593,12 +115593,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]uint8 var _ /* stack at bp+0 */ [4097]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115633,27 +115633,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') - p++ + p = p + 1 /* Initial // is special. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v5] = uint8('/') + v4 = q + q = q + 1 + (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115663,17 +115663,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v7] = uint8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) - p += l + p = p + l up = 0 if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115682,8 +115682,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115712,23 +115712,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115736,10 +115736,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115747,7 +115747,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115761,26 +115761,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v11] = uint8('/') + v4 = l + l = l + 1 + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116304,19 +116304,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]uint8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116334,12 +116334,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v2] = uint8('\n') + v1 = l + l = l + 1 + (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+688, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116592,7 +116592,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -116837,11 +116837,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -116880,9 +116880,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -116891,10 +116891,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -117056,12 +117056,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + wn = wn - 1 goto _4 _4: } @@ -117076,44 +117076,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117133,76 +117133,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117351,31 +117351,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } @@ -117421,16 +117421,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117446,9 +117446,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]uint8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117462,9 +117462,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117484,13 +117484,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117509,13 +117509,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118630,9 +118630,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118643,8 +118643,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118656,20 +118656,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -118682,34 +118682,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -118723,17 +118723,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -118784,22 +118784,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -118821,9 +118821,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -118859,26 +118859,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*uint8)(unsafe.Pointer(v3)) = uint8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) } } else { *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -118891,7 +118891,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -118926,7 +118926,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119036,9 +119036,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119050,31 +119050,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -119082,7 +119082,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119424,7 +119424,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119436,7 +119436,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119476,11 +119476,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1015 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119523,9 +119523,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119534,15 +119534,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119559,7 +119559,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -119571,16 +119571,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -119683,7 +119683,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -119753,13 +119753,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -119890,7 +119890,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119955,15 +119955,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -120013,7 +120013,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120072,41 +120072,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120368,7 +120368,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120549,17 +120549,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120572,29 +120572,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8('.') - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+1046) } @@ -120604,15 +120604,15 @@ var _xdigits = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1055, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120627,7 +120627,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120645,14 +120645,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120665,35 +120665,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*uint8)(unsafe.Pointer(p)) != 0; v13 { - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*uint8)(unsafe.Pointer(z)) != 0; v18 { - v15 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { @@ -120707,7 +120707,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -120715,7 +120715,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]uint8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1079, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -120725,7 +120725,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120743,14 +120743,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -120850,7 +120850,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8('%') Xstrcat(tls, bp+78, p) @@ -120955,7 +120955,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121034,12 +121034,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(32) defer tls.Free(32) - var r, v17, v26, v8 int64 - var r1, v1, v10, v19 int32 + var r, v8 int64 + var r1, v1 int32 var tv uintptr - var v11, v12, v13, v14, v15, v16, v2, v20, v21, v22, v23, v24, v25, v3, v4, v5, v6, v7 Tsyscall_arg_t + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t var _ /* tv32 at bp+8 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v11, v12, v13, v14, v15, v16, v17, v19, v2, v20, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) v2 = int64(fd) @@ -121083,27 +121083,27 @@ _9: *(*[1]Tsocklen_t)(unsafe.Pointer(bp)) = [1]Tsocklen_t{ 0: uint32(16), } - v10 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v11 = int64(fd) - v12 = int64(level) - v13 = int64(optname) - v14 = int64(bp + 8) - v15 = int64(bp) - v16 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp + 8) + v6 = int64(bp) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v10), v11, v12, v13, v14, v15, v16) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v17 = r + v8 = r goto _18 } - v17 = r + v8 = r goto _18 _18: - r1 = int32(v17) + r1 = int32(v8) if r1 < 0 { break } @@ -121123,27 +121123,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v19 = int32(SYS_getsockopt) + v1 = int32(SYS_getsockopt) _ = int32(__SC_getsockopt) - v20 = int64(fd) - v21 = int64(level) - v22 = int64(optname) - v23 = int64(optval) - v24 = int64(optlen) - v25 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = int64(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v19), v20, v21, v22, v23, v24, v25) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v26 = r + v8 = r goto _27 } - v26 = r + v8 = r goto _27 _27: - r1 = int32(v26) + r1 = int32(v8) break } } @@ -121193,7 +121193,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -121205,16 +121205,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121385,7 +121385,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121431,14 +121431,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121460,9 +121460,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121472,11 +121472,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121524,7 +121524,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121554,7 +121554,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -121581,12 +121581,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Uint8FromUint8(':') @@ -121713,7 +121713,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -121727,11 +121727,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -121752,7 +121752,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -121764,11 +121764,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -121778,7 +121778,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { @@ -121789,9 +121789,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*uint8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -121799,22 +121799,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -121831,15 +121831,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -121852,7 +121852,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -121860,16 +121860,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -121948,7 +121948,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -121998,14 +121998,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122013,23 +122013,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122038,9 +122038,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122058,14 +122058,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122088,15 +122088,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122115,7 +122115,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122123,26 +122123,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*uint8)(unsafe.Pointer(p)) != 0; v17 { - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*uint8)(unsafe.Pointer(v18)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122154,35 +122154,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*uint8)(unsafe.Pointer(p)) != 0; v23 { - v20 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*uint8)(unsafe.Pointer(z)) != 0; v28 { - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { @@ -122192,11 +122192,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122243,7 +122243,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122288,14 +122288,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122317,7 +122317,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122332,7 +122332,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122357,13 +122357,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]uint8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122377,19 +122377,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*uint8)(unsafe.Pointer(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122420,23 +122420,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122522,7 +122522,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -122558,7 +122558,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -122578,7 +122578,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -122588,7 +122588,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*uint8)(unsafe.Pointer(canon)) = uint8(0) if name != 0 { @@ -122606,7 +122606,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -122640,7 +122640,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -122649,18 +122649,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -122678,7 +122678,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -122697,7 +122697,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -122751,31 +122751,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122922,19 +122922,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*uint8)(unsafe.Pointer(p)) != 0; v19 { - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -122946,9 +122946,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1098, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -122956,18 +122956,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123130,34 +123130,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123172,21 +123172,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123199,14 +123199,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123233,7 +123233,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123244,18 +123244,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123272,8 +123272,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123308,22 +123308,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123334,7 +123334,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123457,7 +123457,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -123554,7 +123554,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -123566,11 +123566,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -123622,11 +123622,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -123635,14 +123635,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 40 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 40 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -123660,10 +123660,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v9 int64 var r1 Tssize_t - var v1, v2 int32 + var v1 int32 var v3, v4, v5, v6, v7, v8 Tsyscall_arg_t var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v3, v4, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -123673,7 +123673,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp))).F__pad1 = v1 msg = bp } - v2 = int32(SYS_recvmsg) + v1 = int32(SYS_recvmsg) _ = int32(__SC_recvmsg) v3 = int64(fd) v4 = int64(msg) @@ -123682,9 +123682,9 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { v7 = int64(Int32FromInt32(0)) v8 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = ___syscall_cp(tls, int64(v1), v3, v4, v5, v6, v7, v8) } else { - r = X__syscall6(tls, int64(v2), v3, v4, v5, v6, v7, v8) + r = X__syscall6(tls, int64(v1), v3, v4, v5, v6, v7, v8) } if r != int64(-Int32FromInt32(ENOSYS)) { v9 = r @@ -123725,7 +123725,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -123753,7 +123753,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -123896,7 +123896,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -123964,9 +123964,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -123986,7 +123986,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -124007,7 +124007,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124077,7 +124077,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124091,7 +124091,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -124125,7 +124125,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124152,7 +124152,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124180,7 +124180,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124202,13 +124202,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124247,7 +124247,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124261,7 +124261,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124278,10 +124278,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124299,7 +124299,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124358,7 +124358,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124410,7 +124410,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124433,7 +124433,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124463,9 +124463,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124480,11 +124480,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -124514,16 +124514,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]uint8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -124560,7 +124560,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1213) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -124573,103 +124573,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1220) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1230) if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1239, uint64(10)) != 0); v11 { - v8 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1239, uint64(10)) != 0); v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1250, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1257, uint64(6)) != 0; !v24 { - v21 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1250, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1257, uint64(6)) != 0; !v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -124729,7 +124729,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -124750,13 +124750,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1120) defer tls.Free(1120) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v12 int64 - var v1, v5 int32 + var v1 int32 var v10, v11, v6, v7, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+56 */ [66]Tcmsghdr var _ /* h at bp+0 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v3, v6, v7, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -124785,15 +124785,15 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) + v1 = int32(SYS_sendmsg) _ = int32(__SC_sendmsg) v6 = int64(fd) v7 = int64(msg) @@ -124802,9 +124802,9 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { v10 = int64(Int32FromInt32(0)) v11 = int64(Int32FromInt32(0)) if int32(1) != 0 { - r = ___syscall_cp(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = ___syscall_cp(tls, int64(v1), v6, v7, v8, v9, v10, v11) } else { - r = X__syscall6(tls, int64(v5), v6, v7, v8, v9, v10, v11) + r = X__syscall6(tls, int64(v1), v6, v7, v8, v9, v10, v11) } if r != int64(-Int32FromInt32(ENOSYS)) { v12 = r @@ -124875,14 +124875,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var r, v18, v27, v8 int64 - var r1, v1, v11, v20 int32 + var r, v8 int64 + var r1, v1 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v10 uint64 - var v12, v13, v14, v15, v16, v17, v2, v21, v22, v23, v24, v25, v26, v3, v4, v5, v6, v7 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v2, v20, v21, v22, v23, v24, v25, v26, v27, v3, v4, v5, v6, v7, v8 + var v2, v3, v4, v5, v6, v7 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v2, v3, v4, v5, v6, v7, v8 v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) v2 = int64(fd) @@ -124938,27 +124938,27 @@ _9: 0: s, 1: int64(Int32FromUint64(v10)), } - v11 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v12 = int64(fd) - v13 = int64(level) - v14 = int64(optname) - v15 = int64(bp) - v16 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v17 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(bp) + v6 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v11), v12, v13, v14, v15, v16, v17) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v18 = r + v8 = r goto _19 } - v18 = r + v8 = r goto _19 _19: - r1 = int32(v18) + r1 = int32(v8) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -124971,27 +124971,27 @@ _9: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v20 = int32(SYS_setsockopt) + v1 = int32(SYS_setsockopt) _ = int32(__SC_setsockopt) - v21 = int64(fd) - v22 = int64(level) - v23 = int64(optname) - v24 = int64(optval) - v25 = Int64FromUint32(optlen) - v26 = int64(Int32FromInt32(0)) + v2 = int64(fd) + v3 = int64(level) + v4 = int64(optname) + v5 = int64(optval) + v6 = Int64FromUint32(optlen) + v7 = int64(Int32FromInt32(0)) if 0 != 0 { - r = ___syscall_cp(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = ___syscall_cp(tls, int64(v1), v2, v3, v4, v5, v6, v7) } else { - r = X__syscall6(tls, int64(v20), v21, v22, v23, v24, v25, v26) + r = X__syscall6(tls, int64(v1), v2, v3, v4, v5, v6, v7) } if r != int64(-Int32FromInt32(ENOSYS)) { - v27 = r + v8 = r goto _28 } - v27 = r + v8 = r goto _28 _28: - r1 = int32(v27) + r1 = int32(v8) break } } @@ -125271,18 +125271,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125297,14 +125297,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]uint8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125326,11 +125326,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -125370,11 +125370,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -125388,12 +125388,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -125406,11 +125406,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -125435,14 +125435,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -125504,9 +125504,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -125519,7 +125519,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -125636,7 +125636,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -125648,13 +125648,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -125675,32 +125675,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -125712,12 +125712,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -125737,21 +125737,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -125774,8 +125774,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -125788,7 +125788,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -125832,7 +125832,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -125860,7 +125860,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -125871,17 +125871,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -125896,18 +125896,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -125930,18 +125930,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125956,11 +125956,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]uint8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -125982,11 +125982,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]uint8)(unsafe.Pointer(bp + 44)) = [11]uint8{} @@ -126038,11 +126038,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126206,7 +126206,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126220,10 +126220,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126244,57 +126244,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v10)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v14)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126362,10 +126362,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -126451,7 +126451,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -126466,15 +126466,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -126877,7 +126877,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -126949,8 +126949,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -126960,14 +126960,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127023,7 +127023,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127039,7 +127039,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127067,7 +127067,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127083,7 +127083,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127111,7 +127111,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127127,7 +127127,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127157,11 +127157,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1400) seen_eacces = 0 @@ -127188,7 +127188,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } @@ -127208,9 +127208,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -127693,7 +127693,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -127701,12 +127701,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -127715,12 +127715,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -127729,7 +127729,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -127782,22 +127782,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -127815,15 +127815,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -127841,7 +127841,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -127849,7 +127849,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -127857,13 +127857,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { @@ -127877,26 +127877,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -127906,8 +127906,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -127932,13 +127932,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -127958,18 +127958,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v10)))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -127977,7 +127977,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -127987,22 +127987,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128024,7 +128024,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128036,11 +128036,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128050,7 +128050,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -128061,9 +128061,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -128071,7 +128071,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128099,7 +128099,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128111,7 +128111,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128143,7 +128143,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128198,13 +128198,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(128) defer tls.Free(128) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep uint8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128216,9 +128216,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128235,8 +128235,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128256,7 +128256,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128265,9 +128265,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -128276,9 +128276,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128292,7 +128292,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { @@ -128327,19 +128327,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = uint8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 607 + v2 = __ccgo_ts + 607 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128349,9 +128349,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -128389,11 +128389,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*uint8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -128439,13 +128439,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 uint8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 uint8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -128453,16 +128453,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*uint8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1434) + v2 = Xgetenv(tls, __ccgo_ts+1434) } - home = v3 + home = v2 if !(home != 0) { if *(*uint8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -128497,20 +128497,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) } if *(*uint8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v13))) = uint8(0) + v1 = delim + *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -128584,7 +128584,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -128592,7 +128592,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -128606,7 +128606,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -128622,7 +128622,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -128636,7 +128636,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -128661,7 +128661,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -129057,7 +129057,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129098,7 +129098,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -129108,7 +129108,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129206,7 +129206,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129244,16 +129244,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129266,8 +129266,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129278,16 +129278,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129298,11 +129298,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129351,11 +129351,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]uint8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -129380,7 +129380,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('[') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*uint8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -129395,21 +129395,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -129417,7 +129417,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -129425,9 +129425,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129460,11 +129460,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -129477,7 +129477,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -129536,11 +129536,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -129559,13 +129559,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -129578,7 +129578,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -129605,12 +129605,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -129624,7 +129624,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -129647,7 +129647,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -129673,11 +129673,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('['): @@ -129719,7 +129719,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { case 0: @@ -129733,12 +129733,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -129753,20 +129753,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -129782,7 +129782,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -129791,47 +129791,47 @@ _2: if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -129840,7 +129840,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -129849,7 +129849,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -129893,8 +129893,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -129912,12 +129912,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -129926,7 +129926,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -129934,28 +129934,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -129994,7 +129994,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130018,7 +130018,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130039,24 +130039,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130197,7 +130197,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130257,7 +130257,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130298,7 +130298,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130311,7 +130311,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130329,7 +130329,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130342,7 +130342,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130361,7 +130361,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -130396,13 +130396,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -130410,8 +130410,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -130446,7 +130446,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -130516,20 +130516,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -130613,26 +130613,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -130646,7 +130646,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -130740,7 +130740,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -130762,13 +130762,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -130823,8 +130823,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131063,7 +131063,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131104,7 +131104,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131147,7 +131147,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131164,8 +131164,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131228,7 +131228,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131238,7 +131238,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131248,7 +131248,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131277,7 +131277,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131292,7 +131292,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131303,7 +131303,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -131311,7 +131311,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131337,7 +131337,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131352,7 +131352,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -131360,7 +131360,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -131374,9 +131374,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -131405,7 +131405,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -131413,13 +131413,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -131720,9 +131720,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -131776,7 +131776,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -131791,7 +131791,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -131801,13 +131801,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -131825,7 +131825,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -131846,14 +131846,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -131868,7 +131868,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132051,7 +132051,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132096,7 +132096,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132106,12 +132106,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -132133,7 +132133,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132164,7 +132164,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132176,7 +132176,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132239,7 +132239,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132272,7 +132272,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132313,11 +132313,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132360,7 +132360,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -132412,13 +132412,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132471,44 +132471,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -132519,10 +132519,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -132530,10 +132530,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -132556,7 +132556,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -132579,7 +132579,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -132600,18 +132600,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -132646,7 +132646,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -132695,7 +132695,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -132726,7 +132726,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -132750,7 +132750,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -132831,13 +132831,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132901,7 +132901,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -132912,12 +132912,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -132925,10 +132925,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -132998,7 +132998,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133048,7 +133048,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133079,21 +133079,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133104,18 +133104,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133186,7 +133186,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133214,9 +133214,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133243,7 +133243,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133299,8 +133299,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133323,7 +133323,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133339,23 +133339,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -133510,7 +133510,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -133581,7 +133581,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -133604,7 +133604,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -133632,8 +133632,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -133676,8 +133676,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -133733,11 +133733,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -133816,7 +133816,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -133848,7 +133848,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -133869,9 +133869,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -133880,11 +133880,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -133893,9 +133893,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -133904,14 +133904,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -133921,13 +133921,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134068,17 +134068,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134088,9 +134088,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -134105,15 +134105,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134273,8 +134273,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -134507,8 +134507,8 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) } bp := tls.Alloc(80) defer tls.Free(80) - var old, old1, r, tmp, v10, v15, v4 int32 - var v1, v14, v19, v20, v3, v8, v9 uintptr + var old, old1, r, v10, v15, v4 int32 + var v1, v14, v3, v8, v9 uintptr var v2 int64 var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+48 */ Tk_sigaction @@ -134516,7 +134516,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, tmp, v1, v10, v14, v15, v19, v2, v20, v3, v4, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, r, v1, v10, v14, v15, v2, v3, v4, v8, v9 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -134637,16 +134637,16 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old2 uintptr) (r1 int32) Xmemcpy(tls, bp+16+16, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v19 = bp + 16 + v1 = bp + 16 } else { - v19 = uintptr(0) + v1 = uintptr(0) } if old2 != 0 { - v20 = bp + 48 + v3 = bp + 48 } else { - v20 = uintptr(0) + v3 = uintptr(0) } - r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v19), int64(v20), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old2 != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old2)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler (*Tsigaction)(unsafe.Pointer(old2)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) @@ -134748,7 +134748,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -134824,7 +134824,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -134863,7 +134863,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135199,7 +135199,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -135360,7 +135360,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -135638,19 +135638,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -135695,7 +135695,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -135804,13 +135804,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -135832,12 +135832,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -135861,11 +135861,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -135874,11 +135874,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -135908,9 +135908,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -135924,9 +135924,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -135947,8 +135947,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -135959,9 +135959,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136130,8 +136130,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136140,9 +136140,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -136213,7 +136213,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136326,16 +136326,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -136349,7 +136349,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136363,11 +136363,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136388,9 +136388,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -136406,9 +136406,9 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r int32) { - var c, old, old1, tmp, v1, v10, v13, v14, v3, v7 int32 + var c, old, old1, v1, v10, v13, v3, v7 int32 var v12, v4, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, tmp, v1, v10, v12, v13, v14, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v12, v13, v3, v4, v5, v6, v7 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -136425,12 +136425,12 @@ _2: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { - v3 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v3 + c = v1 v6 = f + 140 for { old1 = AtomicLoadPInt32(v6) @@ -136444,28 +136444,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1547) - v7 = old + v3 = old goto _8 _8: ; - if !(v7 != old1) { + if !(v3 != old1) { break } } - v10 = old1 + v7 = old1 goto _11 _11: - if v10&int32(MAYBE_WAITERS) != 0 { + if v7&int32(MAYBE_WAITERS) != 0 { v12 = f + 140 + v10 = int32(1) v13 = int32(1) - v14 = int32(1) - if v14 != 0 { - v14 = int32(FUTEX_PRIVATE) + if v13 != 0 { + v13 = int32(FUTEX_PRIVATE) } - if v13 < Int32FromInt32(0) { - v13 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -136484,7 +136484,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -136507,9 +136507,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136520,21 +136520,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -136571,13 +136571,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136596,7 +136596,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*uint8)(unsafe.Pointer(s)) = uint8(0) return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -136614,8 +136614,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -136623,24 +136623,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = Uint8FromInt32(c) - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } @@ -136687,7 +136687,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -136777,22 +136777,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -136810,7 +136810,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -136820,11 +136820,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -136938,7 +136938,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137101,11 +137101,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -137119,8 +137119,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137132,10 +137132,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137147,9 +137147,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -137277,10 +137277,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, tmp, v1, v11, v14, v15, v3, v8 int32 - var v13, v5, v6, v7 uintptr + var old, old1, v1, v11, v3, v8 int32 + var v5, v6 uintptr var v4 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, tmp, v1, v11, v13, v14, v15, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v3, v4, v5, v6, v8 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -137298,16 +137298,16 @@ _2: v4 = Uint8FromInt32(c) v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 *(*uint8)(unsafe.Pointer(v5)) = v4 - v3 = Int32FromUint8(v4) + v1 = Int32FromUint8(v4) } else { - v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v3 - v7 = f + 140 + c = v1 + v5 = f + 140 for { - old1 = AtomicLoadPInt32(v7) + old1 = AtomicLoadPInt32(v5) goto _10 _10: ; @@ -137318,28 +137318,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1560) - v8 = old + v1 = old goto _9 _9: ; - if !(v8 != old1) { + if !(v1 != old1) { break } } - v11 = old1 + v3 = old1 goto _12 _12: - if v11&int32(MAYBE_WAITERS) != 0 { - v13 = f + 140 - v14 = int32(1) - v15 = int32(1) - if v15 != 0 { - v15 = int32(FUTEX_PRIVATE) + if v3&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v8 = int32(1) + v11 = int32(1) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v14 < Int32FromInt32(0) { - v14 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v11), int64(v8)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v8)) != 0 } return c } @@ -137361,7 +137361,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -137419,7 +137419,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -137549,8 +137549,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -137574,8 +137574,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -137583,11 +137583,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137597,8 +137597,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -137642,7 +137642,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -137709,8 +137709,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -137718,7 +137718,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -137738,9 +137738,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -137817,10 +137817,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -137927,10 +137927,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var old, owner, tid, tmp, v1, v2 int32 + var old, owner, tid, v1 int32 var self Tpthread_t var v4 bool - _, _, _, _, _, _, _, _ = old, owner, self, tid, tmp, v1, v2, v4 + _, _, _, _, _, _ = old, owner, self, tid, v1, v4 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -137938,7 +137938,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -137954,11 +137954,11 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1599) - v2 = old + v1 = old goto _3 _3: } - if v4 || v2 != 0 { + if v4 || v1 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -137974,7 +137974,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -137983,9 +137983,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138008,11 +138008,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138060,15 +138060,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138138,9 +138138,9 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r int32) { - var c, old, old1, tmp, v1, v10, v13, v14, v3, v7 int32 + var c, old, old1, v1, v10, v13, v3, v7 int32 var v12, v4, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, tmp, v1, v10, v12, v13, v14, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v12, v13, v3, v4, v5, v6, v7 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -138157,12 +138157,12 @@ _2: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { - v3 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v3 + c = v1 v6 = f + 140 for { old1 = AtomicLoadPInt32(v6) @@ -138176,28 +138176,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1547) - v7 = old + v3 = old goto _8 _8: ; - if !(v7 != old1) { + if !(v3 != old1) { break } } - v10 = old1 + v7 = old1 goto _11 _11: - if v10&int32(MAYBE_WAITERS) != 0 { + if v7&int32(MAYBE_WAITERS) != 0 { v12 = f + 140 + v10 = int32(1) v13 = int32(1) - v14 = int32(1) - if v14 != 0 { - v14 = int32(FUTEX_PRIVATE) + if v13 != 0 { + v13 = int32(FUTEX_PRIVATE) } - if v13 < Int32FromInt32(0) { - v13 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -138216,7 +138216,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138249,7 +138249,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -138274,9 +138274,9 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r int32) { - var c, old, old1, tmp, v1, v10, v13, v14, v3, v7 int32 + var c, old, old1, v1, v10, v13, v3, v7 int32 var v12, v4, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, tmp, v1, v10, v12, v13, v14, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, old1, v1, v10, v12, v13, v3, v4, v5, v6, v7 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -138293,12 +138293,12 @@ _2: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v5 = f + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { - v3 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v3 + c = v1 v6 = f + 140 for { old1 = AtomicLoadPInt32(v6) @@ -138312,28 +138312,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1547) - v7 = old + v3 = old goto _8 _8: ; - if !(v7 != old1) { + if !(v3 != old1) { break } } - v10 = old1 + v7 = old1 goto _11 _11: - if v10&int32(MAYBE_WAITERS) != 0 { + if v7&int32(MAYBE_WAITERS) != 0 { v12 = f + 140 + v10 = int32(1) v13 = int32(1) - v14 = int32(1) - if v14 != 0 { - v14 = int32(FUTEX_PRIVATE) + if v13 != 0 { + v13 = int32(FUTEX_PRIVATE) } - if v13 < Int32FromInt32(0) { - v13 = int32(INT_MAX) + if v10 < Int32FromInt32(0) { + v10 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v14), int64(v13)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v13)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)|v13), int64(v10)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v12), int64(Int32FromInt32(FUTEX_WAKE)), int64(v10)) != 0 } return c } @@ -138352,7 +138352,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138377,7 +138377,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138390,12 +138390,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 uint8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138431,7 +138431,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -138458,7 +138458,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -138466,14 +138466,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138485,14 +138485,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break @@ -138544,7 +138544,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138555,7 +138555,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) } *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) @@ -138734,17 +138734,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138760,9 +138760,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*uint8)(unsafe.Pointer(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138878,17 +138878,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -138904,9 +138904,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -138997,10 +138997,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, tmp, v1, v11, v14, v15, v3, v8 int32 - var v13, v5, v6, v7 uintptr + var old, old1, v1, v11, v3, v8 int32 + var v5, v6 uintptr var v4 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, tmp, v1, v11, v13, v14, v15, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v3, v4, v5, v6, v8 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -139018,16 +139018,16 @@ _2: v4 = Uint8FromInt32(c) v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 *(*uint8)(unsafe.Pointer(v5)) = v4 - v3 = Int32FromUint8(v4) + v1 = Int32FromUint8(v4) } else { - v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v3 - v7 = f + 140 + c = v1 + v5 = f + 140 for { - old1 = AtomicLoadPInt32(v7) + old1 = AtomicLoadPInt32(v5) goto _10 _10: ; @@ -139038,28 +139038,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1560) - v8 = old + v1 = old goto _9 _9: ; - if !(v8 != old1) { + if !(v1 != old1) { break } } - v11 = old1 + v3 = old1 goto _12 _12: - if v11&int32(MAYBE_WAITERS) != 0 { - v13 = f + 140 - v14 = int32(1) - v15 = int32(1) - if v15 != 0 { - v15 = int32(FUTEX_PRIVATE) + if v3&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v8 = int32(1) + v11 = int32(1) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v14 < Int32FromInt32(0) { - v14 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v11), int64(v8)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v8)) != 0 } return c } @@ -139081,7 +139081,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139117,7 +139117,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139143,10 +139143,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { - var old, old1, tmp, v1, v11, v14, v15, v3, v8 int32 - var v13, v5, v6, v7 uintptr + var old, old1, v1, v11, v3, v8 int32 + var v5, v6 uintptr var v4 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, old1, tmp, v1, v11, v13, v14, v15, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _ = old, old1, v1, v11, v3, v4, v5, v6, v8 // __asm__ __volatile__ ( // // "\n1: lr.w.aqrl %0, (%2)\n bne %0, %3, 1f\n sc.w.aqrl %1, %4, (%2)\n bnez %1, 1b\n1:" @@ -139164,16 +139164,16 @@ _2: v4 = Uint8FromInt32(c) v6 = f + 40 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 *(*uint8)(unsafe.Pointer(v5)) = v4 - v3 = Int32FromUint8(v4) + v1 = Int32FromUint8(v4) } else { - v3 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v3 - v7 = f + 140 + c = v1 + v5 = f + 140 for { - old1 = AtomicLoadPInt32(v7) + old1 = AtomicLoadPInt32(v5) goto _10 _10: ; @@ -139184,28 +139184,28 @@ _2: // : "r"(p), "r"((long)t), "r"((long)s) // : "memory"); X__assert_fail(tls, __ccgo_ts+353, __ccgo_ts+388, 11, __ccgo_ts+1560) - v8 = old + v1 = old goto _9 _9: ; - if !(v8 != old1) { + if !(v1 != old1) { break } } - v11 = old1 + v3 = old1 goto _12 _12: - if v11&int32(MAYBE_WAITERS) != 0 { - v13 = f + 140 - v14 = int32(1) - v15 = int32(1) - if v15 != 0 { - v15 = int32(FUTEX_PRIVATE) + if v3&int32(MAYBE_WAITERS) != 0 { + v6 = f + 140 + v8 = int32(1) + v11 = int32(1) + if v11 != 0 { + v11 = int32(FUTEX_PRIVATE) } - if v14 < Int32FromInt32(0) { - v14 = int32(INT_MAX) + if v8 < Int32FromInt32(0) { + v8 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)|v15), int64(v14)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v13), int64(Int32FromInt32(FUTEX_WAKE)), int64(v14)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)|v11), int64(v8)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v6), int64(Int32FromInt32(FUTEX_WAKE)), int64(v8)) != 0 } return c } @@ -139227,7 +139227,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139255,7 +139255,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139285,7 +139285,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -139621,7 +139621,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139656,7 +139656,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139692,7 +139692,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -139726,7 +139726,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -139743,12 +139743,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 152 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -139765,10 +139765,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -139777,13 +139777,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140059,7 +140059,7 @@ func _pad3(tls *TLS, f uintptr, c uint8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -140073,13 +140073,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140091,45 +140091,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -140144,13 +140144,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]uint8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140159,7 +140159,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]uint8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1625 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -140172,21 +140172,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*uint8)(unsafe.Pointer(v10)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v11)) = Uint8FromInt32(v12) - estr-- - v13 = estr - *(*uint8)(unsafe.Pointer(v13)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*uint8)(unsafe.Pointer(v15)) = uint8('.') + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140298,46 +140298,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -140353,22 +140353,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -140387,21 +140387,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -140413,8 +140413,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -140424,10 +140424,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -140435,15 +140435,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -140455,23 +140455,23 @@ _4: } } if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -140482,8 +140482,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -140502,14 +140502,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -140523,8 +140523,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -140548,21 +140548,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -140575,31 +140575,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*uint8)(unsafe.Pointer(v43)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v44)) = Uint8FromInt32(v45) - estr-- - v46 = estr - *(*uint8)(unsafe.Pointer(v46)) = Uint8FromInt32(t) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -140623,15 +140623,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*uint8)(unsafe.Pointer(v48)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*uint8)(unsafe.Pointer(v49)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -140649,21 +140649,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*uint8)(unsafe.Pointer(v51)) = uint8('0') + s3 = s3 - 1 + v5 = s3 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, uint8('0'), p+int32(9), int32(9), 0) } else { @@ -140677,30 +140677,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*uint8)(unsafe.Pointer(v54)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*uint8)(unsafe.Pointer(v55)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+607, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -140712,11 +140712,11 @@ _4: } _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -140735,7 +140735,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -140743,19 +140743,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]uint8 var _ /* mb at bp+48 */ [4]uint8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -140768,7 +140768,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -140781,7 +140781,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -140791,8 +140791,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -140807,10 +140807,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -140818,11 +140818,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -140834,7 +140834,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -140843,19 +140843,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -140868,16 +140868,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -140885,7 +140885,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -140901,7 +140901,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -140940,11 +140940,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141020,14 +141020,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141053,10 +141053,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141071,7 +141071,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -141089,12 +141089,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*uint8)(unsafe.Pointer(v35)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141108,24 +141108,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1666 + v8 = __ccgo_ts + 1666 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141139,23 +141139,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -141168,28 +141168,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141254,7 +141254,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141263,7 +141263,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -141289,12 +141289,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -141333,11 +141333,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -141391,7 +141391,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -141405,17 +141405,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -141438,99 +141438,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -141541,33 +141541,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -141621,14 +141621,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -141646,85 +141646,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -141738,10 +141738,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -141749,11 +141749,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -141765,36 +141765,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -141807,16 +141807,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -141827,12 +141827,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -141851,23 +141851,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v73))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -141876,40 +141876,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v79))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -141917,7 +141917,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -141940,26 +141940,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -141974,15 +141974,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -141991,6 +141983,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142006,20 +142006,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142031,7 +142031,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142040,7 +142040,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142212,7 +142212,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142269,7 +142269,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -142277,7 +142277,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]uint8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -142290,7 +142290,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -142314,7 +142314,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142329,7 +142329,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -142340,7 +142340,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) goto _4 _4: ; @@ -142352,7 +142352,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -142367,13 +142367,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -142382,16 +142382,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -142447,7 +142447,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -142489,11 +142489,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -142514,27 +142514,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1666 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -142549,13 +142549,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -142607,7 +142607,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -142616,7 +142616,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -142708,7 +142708,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -142751,7 +142751,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -142772,14 +142772,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -142804,23 +142804,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142831,37 +142831,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -142870,7 +142870,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -142880,7 +142880,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -142891,8 +142891,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -142905,9 +142905,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -142979,45 +142979,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143044,8 +143044,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143064,17 +143064,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143082,11 +143082,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -143101,27 +143101,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143131,17 +143131,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143150,16 +143150,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143217,23 +143217,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1709, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1727, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143241,7 +143241,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143253,7 +143253,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143262,7 +143262,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143343,8 +143343,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143358,11 +143358,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -143483,11 +143483,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -143505,9 +143505,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -143521,9 +143521,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -143568,9 +143568,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -143588,10 +143588,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -143710,9 +143710,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -143723,27 +143723,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -143765,19 +143765,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143807,19 +143807,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -143844,11 +143844,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -143875,9 +143875,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]uint8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -143894,9 +143894,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144072,9 +144072,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144083,7 +144083,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -144094,7 +144094,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -144106,10 +144106,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144120,16 +144120,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144160,12 +144160,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144212,13 +144212,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -144234,17 +144234,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -144252,7 +144252,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -144283,9 +144283,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -144295,11 +144295,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144472,7 +144472,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144480,7 +144480,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144491,11 +144491,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144516,11 +144516,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144576,7 +144576,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144584,7 +144584,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144595,11 +144595,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144620,11 +144620,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144734,9 +144734,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -144752,9 +144752,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -144770,7 +144770,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -144778,19 +144778,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -144829,8 +144829,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -144843,7 +144843,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -144854,8 +144854,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -144882,9 +144882,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -144902,9 +144902,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -144912,14 +144912,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -144933,32 +144933,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -144969,22 +144969,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -145000,23 +145000,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -145032,18 +145032,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -145059,170 +145059,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145232,27 +145232,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145394,29 +145394,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145451,22 +145451,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145474,10 +145474,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -145490,12 +145490,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145525,7 +145525,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -145550,9 +145550,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145565,14 +145565,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } for { @@ -145583,42 +145583,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } } @@ -145645,7 +145645,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -145703,9 +145703,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -145736,8 +145736,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -145753,8 +145753,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -145784,8 +145784,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 uint8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 uint8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -145799,8 +145799,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -145821,16 +145821,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -145869,9 +145869,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -145884,9 +145884,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { goto tail @@ -145901,7 +145901,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145909,19 +145909,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145963,8 +145963,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146003,7 +146003,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146066,7 +146066,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -146087,7 +146087,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146121,8 +146121,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146143,10 +146143,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) @@ -146154,16 +146154,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -146172,7 +146172,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146254,12 +146254,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 uint8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 uint8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146275,9 +146275,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146290,7 +146290,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146299,19 +146299,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*uint8)(unsafe.Pointer(d)) = uint8(0) goto finish @@ -146350,7 +146350,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146370,7 +146370,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146386,7 +146386,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146397,9 +146397,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146425,21 +146425,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + v1 = d + d = d + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) return a } @@ -146454,7 +146454,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146465,9 +146465,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146523,7 +146523,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*uint8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146554,7 +146554,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { end = uintptr(0) @@ -146580,7 +146580,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -146591,12 +146591,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -146608,10 +146608,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*uint8)(unsafe.Pointer(c)) != 0) { @@ -146625,22 +146625,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -146649,18 +146649,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146792,29 +146792,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -146851,7 +146851,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -146861,22 +146861,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -146884,10 +146884,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -146900,12 +146900,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -146953,9 +146953,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -146963,17 +146963,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v1 = _p2 + _p2 = _p2 + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -146987,9 +146987,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -146997,18 +146997,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147051,7 +147051,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147067,7 +147067,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147096,12 +147096,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -147301,7 +147301,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147314,7 +147314,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -147332,21 +147332,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -147364,7 +147364,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147390,7 +147390,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147422,7 +147422,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147477,10 +147477,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -147490,7 +147490,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147504,23 +147504,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147529,29 +147529,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147588,16 +147588,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -147605,10 +147605,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -147621,12 +147621,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -147662,9 +147662,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147672,18 +147672,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147712,7 +147712,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -147737,7 +147737,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147765,7 +147765,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147784,8 +147784,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -147793,7 +147793,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147801,9 +147801,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -147827,7 +147827,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -147860,7 +147860,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147885,27 +147885,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1769, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -147968,7 +147968,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148179,7 +148179,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148230,38 +148230,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148269,15 +148269,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(Int32FromUint8(_days_in_month[months]) <= remdays) { break } - remdays -= Int32FromUint8(_days_in_month[months]) + remdays = remdays - Int32FromUint8(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148323,19 +148323,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148372,7 +148372,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148382,20 +148382,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148414,21 +148414,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148439,7 +148439,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148451,10 +148451,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148468,7 +148468,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148494,13 +148494,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148510,13 +148510,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]uint8 var _ /* dummy_name at bp+308 */ [7]uint8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1776) @@ -148540,7 +148540,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148554,7 +148554,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -148579,7 +148579,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1779) != 0) { @@ -148601,7 +148601,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -148628,7 +148628,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -148645,16 +148645,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -148674,7 +148674,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -148709,11 +148709,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -148751,10 +148751,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -148783,7 +148783,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -148834,25 +148834,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -148895,16 +148895,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -148977,7 +148977,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -148994,8 +148994,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149005,15 +149005,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149023,11 +149023,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149423,9 +149423,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -149453,9 +149453,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149466,7 +149466,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149475,7 +149475,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149499,10 +149499,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1701 width = int32(2) def_pad = int32('0') @@ -149556,14 +149556,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -149580,7 +149580,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -149611,11 +149611,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -149624,14 +149624,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -149655,11 +149655,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -149719,11 +149719,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1893, VaList(bp+8, val))) case int32('_'): @@ -149765,15 +149765,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]uint8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -149785,21 +149785,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -149816,7 +149816,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -149827,8 +149827,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -149837,8 +149837,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -149851,50 +149851,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v7))) = uint8('-') - width-- + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v10))) = uint8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v12))) = uint8('0') + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -149928,15 +149928,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -149960,21 +149960,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -149984,7 +149984,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150081,7 +150081,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150136,19 +150136,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*uint8)(unsafe.Pointer(s)) != 0; v48 { - v45 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150160,7 +150160,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150168,7 +150168,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150232,7 +150232,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150245,9 +150245,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150266,13 +150266,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150287,30 +150287,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150330,13 +150330,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -150535,7 +150535,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -150543,7 +150543,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -150555,7 +150555,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -150601,40 +150601,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151028,7 +151028,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) @@ -151181,7 +151181,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/ccgo_linux_s390x.go b/vendor/modernc.org/libc/ccgo_linux_s390x.go index 9941527..4e2fdb7 100644 --- a/vendor/modernc.org/libc/ccgo_linux_s390x.go +++ b/vendor/modernc.org/libc/ccgo_linux_s390x.go @@ -542,14 +542,14 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { defer tls.Free(16) var exp_x, scale1, scale2, x, y float64 var half_expt int32 - var v1, v2 Tuint64_t + var v1 Tuint64_t var v3 [2]float64 var _ /* ex_expt at bp+0 */ int32 - _, _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v2, v3 + _, _, _, _, _, _, _, _ = exp_x, half_expt, scale1, scale2, x, y, v1, v3 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] exp_x = ___frexp_exp(tls, x, bp) - expt += *(*int32)(unsafe.Pointer(bp)) + expt = expt + *(*int32)(unsafe.Pointer(bp)) /* * Arrange so that scale1 * scale2 == 2**expt. We use this to * compensate for scalbn being horrendously slow. @@ -558,8 +558,8 @@ func X__ldexp_cexp(tls *TLS, z complex128, expt int32) (r complex128) { v1 = Uint64FromInt32((Int32FromInt32(0x3ff)+half_expt)< %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcasin(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcasinhf(tls *TLS, z complex64) (r complex64) { @@ -890,18 +890,18 @@ func Xcasinhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcasinf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcasinhl(tls *TLS, z complex128) (r complex128) { @@ -933,9 +933,9 @@ func __redupi(tls *TLS, x float64) (r float64) { _, _ = i, t t = x / float64(3.141592653589793) if t >= float64(0) { - t += float64(0.5) + t = t + float64(0.5) } else { - t -= float64(0.5) + t = t - float64(0.5) } i = int64(t) /* the multiple */ t = float64(i) @@ -985,9 +985,9 @@ func __redupif(tls *TLS, xx float32) (r float32) { x = xx t = x / _float_pi if t >= Float32FromFloat32(0) { - t += Float32FromFloat32(0.5) + t = t + Float32FromFloat32(0.5) } else { - t -= Float32FromFloat32(0.5) + t = t - Float32FromFloat32(0.5) } i = int64(t) /* the multiple */ t = float32(i) @@ -1031,18 +1031,18 @@ func Xcatanh(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcatan(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcatanhf(tls *TLS, z complex64) (r complex64) { @@ -1050,18 +1050,18 @@ func Xcatanhf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcatanf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xcatanhl(tls *TLS, z complex128) (r complex128) { @@ -1120,8 +1120,8 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1142,42 +1142,42 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcosh(tls, x) * Xcos(tls, y)), 1: float64(Xsinh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(Xcopysign(tls, h, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: Float64FromComplex128(z), 1: float64(+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] * Xcopysign(tls, Float64FromInt32(1), x)), } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(h*h) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1191,11 +1191,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf +- I 0) = +Inf + I (+-)(+-)0. @@ -1205,17 +1205,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(Xcopysign(tls, Float64FromInt32(0), x) * y), } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: Xcopysign(tls, Float64FromInt32(0), float64((x+x)*y)), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(x +- I Inf) = dNaN + I dNaN. @@ -1226,11 +1226,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(+-Inf + I NaN) = +Inf + I d(NaN). @@ -1243,17 +1243,17 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * Xcos(tls, y)), 1: float64(x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * cosh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -1266,11 +1266,11 @@ func Xccosh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge1 = float32(1.7014118346046923e+38) @@ -1282,8 +1282,8 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -1299,92 +1299,92 @@ func Xccoshf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcoshf(tls, x) * Xcosf(tls, y)), 1: float32(Xsinhf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(Xcopysignf(tls, h, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: Float32FromComplex64(z), 1: float32(+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] * Xcopysignf(tls, Float32FromInt32(1), x)), } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge1 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(h*h) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(Xcopysignf(tls, Float32FromInt32(0), x) * y), } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: Xcopysignf(tls, Float32FromInt32(0), float32((x+x)*y)), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * Xcosf(tls, y)), 1: float32(x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -1417,14 +1417,14 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var exp_x, x, y float64 var hx, hy, lx, ly Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _ = __u, __u1, exp_x, hx, hy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&y)) hy = uint32(__u >> int32(32)) ly = uint32(__u) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy|ly == uint32(0) { v1 = [2]float64{ @@ -1438,32 +1438,32 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { lx = uint32(__u1) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff)|lx == uint32(0) { - v2 = [2]float64{ + v1 = [2]float64{ 0: Xcos(tls, y), 1: Xsin(tls, y), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7ff00000) { if lx != uint32(0) || hx&uint32(0x7fffffff) != uint32(0x7ff00000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float64{} - return *(*complex128)(unsafe.Pointer(&v4)) + v1 = [2]float64{} + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1482,11 +1482,11 @@ func Xcexp(tls *TLS, z complex128) (r complex128) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexp(tls, x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(exp_x * Xcos(tls, y)), 1: float64(exp_x * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } return r } @@ -1501,12 +1501,12 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { } var exp_x, x, y float32 var hx, hy Tuint32_t - var v1, v2, v3, v4, v5, v6 [2]float32 - _, _, _, _, _, _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1, v2, v3, v4, v5, v6 + var v1 [2]float32 + _, _, _, _, _, _ = exp_x, hx, hy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hy = *(*Tuint32_t)(unsafe.Pointer(&y)) - hy &= uint32(0x7fffffff) + hy = hy & uint32(0x7fffffff) /* cexp(x + I 0) = exp(x) + I 0 */ if hy == uint32(0) { v1 = [2]float32{ @@ -1518,32 +1518,32 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { hx = *(*Tuint32_t)(unsafe.Pointer(&x)) /* cexp(0 + I y) = cos(y) + I sin(y) */ if hx&uint32(0x7fffffff) == uint32(0) { - v2 = [2]float32{ + v1 = [2]float32{ 0: Xcosf(tls, y), 1: Xsinf(tls, y), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } if hy >= uint32(0x7f800000) { if hx&uint32(0x7fffffff) != uint32(0x7f800000) { /* cexp(finite|NaN +- I Inf|NaN) = NaN + I NaN */ - v3 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if hx&uint32(0x80000000) != 0 { /* cexp(-Inf +- I Inf|NaN) = 0 + I 0 */ - v4 = [2]float32{} - return *(*complex64)(unsafe.Pointer(&v4)) + v1 = [2]float32{} + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* cexp(+Inf +- I Inf|NaN) = Inf + I NaN */ - v5 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } @@ -1562,11 +1562,11 @@ func Xcexpf(tls *TLS, z complex64) (r complex64) { * - x = NaN (spurious inexact exception from y) */ exp_x = Xexpf(tls, x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(exp_x * Xcosf(tls, y)), 1: float32(exp_x * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -1833,18 +1833,18 @@ func Xcsin(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xcsinh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xcsinf(tls *TLS, z complex64) (r complex64) { @@ -1852,18 +1852,18 @@ func Xcsinf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xcsinhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } var _huge2 = float64(8.98846567431158e+307) @@ -1876,8 +1876,8 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { var __u, __u1 Tuint64_t var h, x, y float64 var hx, hy, ix, iy, lx, ly Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float64 + _, _, _, _, _, _, _, _, _, _, _, _ = __u, __u1, h, hx, hy, ix, iy, lx, ly, x, y, v1 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -1898,42 +1898,42 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { return *(*complex128)(unsafe.Pointer(&v1)) } if ix < int32(0x40360000) { /* small x: normal case */ - v2 = [2]float64{ + v1 = [2]float64{ 0: float64(Xsinh(tls, x) * Xcos(tls, y)), 1: float64(Xcosh(tls, x) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* |x| >= 22, so cosh(x) ~= exp(|x|) */ if ix < int32(0x40862e42) { /* x < 710: exp(|x|) won't overflow */ h = float64(Xexp(tls, Xfabs(tls, x)) * float64(0.5)) - v3 = [2]float64{ + v1 = [2]float64{ 0: float64(Xcopysign(tls, h, x) * Xcos(tls, y)), 1: float64(h * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v3)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4096bbaa) { /* x < 1455: scale to avoid overflow */ - v4 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, x), 1: y, } - z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float64{ + z = X__ldexp_cexp(tls, *(*complex128)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float64{ 0: float64(Float64FromComplex128(z) * Xcopysign(tls, Float64FromInt32(1), x)), 1: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex128)(unsafe.Pointer(&v5)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { /* x >= 1455: the result always overflows */ h = float64(_huge2 * x) - v6 = [2]float64{ + v1 = [2]float64{ 0: float64(h * Xcos(tls, y)), 1: float64(float64(h*h) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v6)) + return *(*complex128)(unsafe.Pointer(&v1)) } } } @@ -1947,11 +1947,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * the same as d(NaN). */ if ix|lx == 0 && iy >= int32(0x7ff00000) { - v7 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(0), float64(x*(y-y))), 1: y - y, } - return *(*complex128)(unsafe.Pointer(&v7)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf +- I 0) = +-Inf + I +-0. @@ -1960,17 +1960,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if iy|ly == 0 && ix >= int32(0x7ff00000) { if hx&int32(0xfffff)|lx == 0 { - v8 = [2]float64{ + v1 = [2]float64{ 0: x, 1: y, } - return *(*complex128)(unsafe.Pointer(&v8)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v9 = [2]float64{ + v1 = [2]float64{ 0: x, 1: Xcopysign(tls, Float64FromInt32(0), y), } - return *(*complex128)(unsafe.Pointer(&v9)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(x +- I Inf) = dNaN + I dNaN. @@ -1981,11 +1981,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * nonzero x. Choice = don't raise (except for signaling NaNs). */ if ix < int32(0x7ff00000) && iy >= int32(0x7ff00000) { - v10 = [2]float64{ + v1 = [2]float64{ 0: y - y, 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v10)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(+-Inf + I NaN) = +-Inf + I d(NaN). @@ -2000,17 +2000,17 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { */ if ix >= int32(0x7ff00000) && hx&int32(0xfffff)|lx == 0 { if iy >= int32(0x7ff00000) { - v11 = [2]float64{ + v1 = [2]float64{ 0: float64(x * x), 1: float64(x * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v11)) + return *(*complex128)(unsafe.Pointer(&v1)) } - v12 = [2]float64{ + v1 = [2]float64{ 0: float64(x * Xcos(tls, y)), 1: float64(float64(X__builtin_inff(tls)) * Xsin(tls, y)), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* * sinh(NaN + I NaN) = d(NaN) + I d(NaN). @@ -2023,11 +2023,11 @@ func Xcsinh(tls *TLS, z complex128) (r complex128) { * Optionally raises the invalid floating-point exception for finite * nonzero y. Choice = don't raise (except for signaling NaNs). */ - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(x*x) * (y - y)), 1: float64((x + x) * (y - y)), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } var _huge3 = float32(1.7014118346046923e+38) @@ -2039,8 +2039,8 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { } var h, x, y float32 var hx, hy, ix, iy Tint32_t - var v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 [2]float32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v7, v8, v9 + var v1 [2]float32 + _, _, _, _, _, _, _, _ = h, hx, hy, ix, iy, x, y, v1 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = Int32FromUint32(*(*Tuint32_t)(unsafe.Pointer(&x))) @@ -2056,92 +2056,92 @@ func Xcsinhf(tls *TLS, z complex64) (r complex64) { return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x41100000) { /* small x: normal case */ - v2 = [2]float32{ + v1 = [2]float32{ 0: float32(Xsinhf(tls, x) * Xcosf(tls, y)), 1: float32(Xcoshf(tls, x) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } /* |x| >= 9, so cosh(x) ~= exp(|x|) */ if ix < int32(0x42b17218) { /* x < 88.7: expf(|x|) won't overflow */ h = float32(Xexpf(tls, Xfabsf(tls, x)) * Float32FromFloat32(0.5)) - v3 = [2]float32{ + v1 = [2]float32{ 0: float32(Xcopysignf(tls, h, x) * Xcosf(tls, y)), 1: float32(h * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v3)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { if ix < int32(0x4340b1e7) { /* x < 192.7: scale to avoid overflow */ - v4 = [2]float32{ + v1 = [2]float32{ 0: Xfabsf(tls, x), 1: y, } - z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v4)), -int32(1)) - v5 = [2]float32{ + z = X__ldexp_cexpf(tls, *(*complex64)(unsafe.Pointer(&v1)), -int32(1)) + v1 = [2]float32{ 0: float32(Float32FromComplex64(z) * Xcopysignf(tls, Float32FromInt32(1), x)), 1: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], } - return *(*complex64)(unsafe.Pointer(&v5)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { /* x >= 192.7: the result always overflows */ h = float32(_huge3 * x) - v6 = [2]float32{ + v1 = [2]float32{ 0: float32(h * Xcosf(tls, y)), 1: float32(float32(h*h) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v6)) + return *(*complex64)(unsafe.Pointer(&v1)) } } } if ix == 0 && iy >= int32(0x7f800000) { - v7 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(0), float32(x*(y-y))), 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v7)) + return *(*complex64)(unsafe.Pointer(&v1)) } if iy == 0 && ix >= int32(0x7f800000) { if hx&int32(0x7fffff) == 0 { - v8 = [2]float32{ + v1 = [2]float32{ 0: x, 1: y, } - return *(*complex64)(unsafe.Pointer(&v8)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v9 = [2]float32{ + v1 = [2]float32{ 0: x, 1: Xcopysignf(tls, Float32FromInt32(0), y), } - return *(*complex64)(unsafe.Pointer(&v9)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix < int32(0x7f800000) && iy >= int32(0x7f800000) { - v10 = [2]float32{ + v1 = [2]float32{ 0: y - y, 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= int32(0x7f800000) && hx&int32(0x7fffff) == 0 { if iy >= int32(0x7f800000) { - v11 = [2]float32{ + v1 = [2]float32{ 0: float32(x * x), 1: float32(x * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v11)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v12 = [2]float32{ + v1 = [2]float32{ 0: float32(x * Xcosf(tls, y)), 1: float32(X__builtin_inff(tls) * Xsinf(tls, y)), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(x*x) * (y - y)), 1: float32((x + x) * (y - y)), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -2185,13 +2185,13 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { var a, b, t float64 var result complex128 var scale int32 - var v1, v12, v13, v14, v15, v4, v7 [2]float64 - var v10, v2, v5, v8 uint64 + var v1 [2]float64 + var v2, v5 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = a, b, result, scale, t, v1, v2, v5 a = Float64FromComplex128(z) b = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2206,29 +2206,29 @@ func Xcsqrt(tls *TLS, z complex128) (r complex128) { goto _3 _3: if BoolInt32(v2&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != 0 { - v12 = [2]float64{ + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { + v1 = [2]float64{ 0: Xfabs(tls, b-b), 1: Xcopysign(tls, a, b), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } else { - v13 = [2]float64{ + v1 = [2]float64{ 0: a, 1: Xcopysign(tls, b-b, b), } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } } /* @@ -2259,8 +2259,8 @@ _9: */ /* Scale to avoid overflow. */ if Xfabs(tls, a) >= float64(7.446288774449766e+307) || Xfabs(tls, b) >= float64(7.446288774449766e+307) { - a *= float64(0.25) - b *= float64(0.25) + a = a * float64(0.25) + b = b * float64(0.25) scale = int32(1) } else { scale = 0 @@ -2268,22 +2268,22 @@ _9: /* Algorithm 312, CACM vol 10, Oct 1967. */ if a >= Float64FromInt32(0) { t = Xsqrt(tls, float64((a+Xhypot(tls, a, b))*float64(0.5))) - v14 = [2]float64{ + v1 = [2]float64{ 0: t, 1: b / float64(Float64FromInt32(2)*t), } - result = *(*complex128)(unsafe.Pointer(&v14)) + result = *(*complex128)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((-a+Xhypot(tls, a, b))*float64(0.5))) - v15 = [2]float64{ + v1 = [2]float64{ 0: Xfabs(tls, b) / float64(Float64FromInt32(2)*t), 1: Xcopysign(tls, t, b), } - result = *(*complex128)(unsafe.Pointer(&v15)) + result = *(*complex128)(unsafe.Pointer(&v1)) } /* Rescale. */ if scale != 0 { - result *= Complex128FromInt32(2) + result = result * Complex128FromInt32(2) } return result } @@ -2305,13 +2305,13 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { defer tls.Free(16) var a, b float32 var t float64 - var v1, v12, v13, v14, v15, v4, v7 [2]float32 - var v10, v2, v5, v8 uint32 + var v1 [2]float32 + var v2, v5 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, t, v1, v10, v12, v13, v14, v15, v2, v4, v5, v7, v8 + _, _, _, _, _, _ = a, b, t, v1, v2, v5 a = Float32FromComplex64(z) b = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] /* Handle special cases. */ @@ -2326,29 +2326,29 @@ func Xcsqrtf(tls *TLS, z complex64) (r complex64) { goto _3 _3: if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v4 = [2]float32{ + v1 = [2]float32{ 0: X__builtin_inff(tls), 1: b, } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = a - v5 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: - if BoolInt32(v5&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { t = float64((b - b) / (b - b)) /* raise invalid if b is not a NaN */ - v7 = [2]float32{ + v1 = [2]float32{ 0: a, 1: float32(t), } - return *(*complex64)(unsafe.Pointer(&v7)) /* return NaN + NaN i */ + return *(*complex64)(unsafe.Pointer(&v1)) /* return NaN + NaN i */ } *(*float32)(unsafe.Pointer(bp)) = a - v8 = *(*uint32)(unsafe.Pointer(bp)) + v2 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if BoolInt32(v8&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { + if BoolInt32(v2&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { /* * csqrtf(inf + NaN i) = inf + NaN i * csqrtf(inf + y i) = inf + 0 i @@ -2356,21 +2356,21 @@ _9: * csqrtf(-inf + y i) = 0 + inf i */ *(*float32)(unsafe.Pointer(bp)) = a - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - v12 = [2]float32{ + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { + v1 = [2]float32{ 0: Xfabsf(tls, b-b), 1: Xcopysignf(tls, a, b), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { - v13 = [2]float32{ + v1 = [2]float32{ 0: a, 1: Xcopysignf(tls, b-b, b), } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } } /* @@ -2384,18 +2384,18 @@ _9: */ if a >= Float32FromInt32(0) { t = Xsqrt(tls, float64((float64(a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v14 = [2]float32{ + v1 = [2]float32{ 0: float32(t), 1: float32(float64(b) / float64(Float64FromFloat64(2)*t)), } - return *(*complex64)(unsafe.Pointer(&v14)) + return *(*complex64)(unsafe.Pointer(&v1)) } else { t = Xsqrt(tls, float64((float64(-a)+Xhypot(tls, float64(a), float64(b)))*float64(0.5))) - v15 = [2]float32{ + v1 = [2]float32{ 0: float32(float64(Xfabsf(tls, b)) / float64(Float64FromFloat64(2)*t)), 1: Xcopysignf(tls, float32(t), b), } - return *(*complex64)(unsafe.Pointer(&v15)) + return *(*complex64)(unsafe.Pointer(&v1)) } return r } @@ -2418,18 +2418,18 @@ func Xctan(tls *TLS, z complex128) (r complex128) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float64 - _, _ = v1, v2 + var v1 [2]float64 + _ = v1 v1 = [2]float64{ 0: -+(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: Float64FromComplex128(z), } z = Xctanh(tls, *(*complex128)(unsafe.Pointer(&v1))) - v2 = [2]float64{ + v1 = [2]float64{ 0: +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)], 1: -Float64FromComplex128(z), } - return *(*complex128)(unsafe.Pointer(&v2)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanf(tls *TLS, z complex64) (r complex64) { @@ -2437,18 +2437,18 @@ func Xctanf(tls *TLS, z complex64) (r complex64) { trc("tls=%v z=%v, (%v:)", tls, z, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 [2]float32 - _, _ = v1, v2 + var v1 [2]float32 + _ = v1 v1 = [2]float32{ 0: -+(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: Float32FromComplex64(z), } z = Xctanhf(tls, *(*complex64)(unsafe.Pointer(&v1))) - v2 = [2]float32{ + v1 = [2]float32{ 0: +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)], 1: -Float32FromComplex64(z), } - return *(*complex64)(unsafe.Pointer(&v2)) + return *(*complex64)(unsafe.Pointer(&v1)) } func Xctanh(tls *TLS, z complex128) (r complex128) { @@ -2459,15 +2459,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { bp := tls.Alloc(16) defer tls.Free(16) var __u1, v3 Tuint64_t - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float64 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float64 var hx, ix, lx Tuint32_t - var v1, v10, v12, v13, v4 [2]float64 - var v6, v8 uint64 + var v1 [2]float64 + var v6 uint64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, beta, denom, exp_mx, hx, ix, lx, rho, s, t, x, y, v1, v2, v3, v6 x = Float64FromComplex128(z) y = +(*(*[2]float64)(unsafe.Pointer(&z)))[int32(1)] __u1 = *(*Tuint64_t)(unsafe.Pointer(&x)) @@ -2510,15 +2510,15 @@ func Xctanh(tls *TLS, z complex128) (r complex128) { goto _7 _7: if BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) == Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= uint32(0x40360000) { /* x >= 22 */ exp_mx = Xexp(tls, -Xfabs(tls, x)) - v12 = [2]float64{ + v1 = [2]float64{ 0: Xcopysign(tls, Float64FromInt32(1), x), 1: float64(float64(float64(float64(Float64FromInt32(4)*Xsin(tls, y))*Xcos(tls, y))*exp_mx) * exp_mx), } - return *(*complex128)(unsafe.Pointer(&v12)) + return *(*complex128)(unsafe.Pointer(&v1)) } /* Kahan's algorithm */ t = Xtan(tls, y) @@ -2561,11 +2561,11 @@ _9: s = Xsinh(tls, x) rho = Xsqrt(tls, Float64FromInt32(1)+float64(s*s)) /* = cosh(x) */ denom = Float64FromInt32(1) + float64(float64(beta*s)*s) - v13 = [2]float64{ + v1 = [2]float64{ 0: float64(float64(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex128)(unsafe.Pointer(&v13)) + return *(*complex128)(unsafe.Pointer(&v1)) } func Xctanhf(tls *TLS, z complex64) (r complex64) { @@ -2575,15 +2575,15 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { } bp := tls.Alloc(16) defer tls.Free(16) - var beta, denom, exp_mx, rho, s, t, x, y, v11, v2, v5 float32 + var beta, denom, exp_mx, rho, s, t, x, y, v2 float32 var hx, ix, v3 Tuint32_t - var v1, v10, v12, v13, v4 [2]float32 - var v6, v8 uint32 + var v1 [2]float32 + var v6 uint32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v10, v11, v12, v13, v2, v3, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = beta, denom, exp_mx, hx, ix, rho, s, t, x, y, v1, v2, v3, v6 x = Float32FromComplex64(z) y = +(*(*[2]float32)(unsafe.Pointer(&z)))[int32(1)] hx = *(*Tuint32_t)(unsafe.Pointer(&x)) @@ -2608,50 +2608,50 @@ func Xctanhf(tls *TLS, z complex64) (r complex64) { goto _7 _7: if BoolInt32(v6&uint32(0x7fffffff) == uint32(0x7f800000)) != 0 { - v5 = y + v2 = y } else { - v5 = float32(Xsinf(tls, y) * Xcosf(tls, y)) + v2 = float32(Xsinf(tls, y) * Xcosf(tls, y)) } - v4 = [2]float32{ + v1 = [2]float32{ 0: x, - 1: Xcopysignf(tls, Float32FromInt32(0), v5), + 1: Xcopysignf(tls, Float32FromInt32(0), v2), } - return *(*complex64)(unsafe.Pointer(&v4)) + return *(*complex64)(unsafe.Pointer(&v1)) } *(*float32)(unsafe.Pointer(bp)) = y - v8 = *(*uint32)(unsafe.Pointer(bp)) + v6 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if !(BoolInt32(v8&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if ix != 0 { - v11 = y - y + v2 = y - y } else { - v11 = x + v2 = x } - v10 = [2]float32{ - 0: v11, + v1 = [2]float32{ + 0: v2, 1: y - y, } - return *(*complex64)(unsafe.Pointer(&v10)) + return *(*complex64)(unsafe.Pointer(&v1)) } if ix >= uint32(0x41300000) { /* x >= 11 */ exp_mx = Xexpf(tls, -Xfabsf(tls, x)) - v12 = [2]float32{ + v1 = [2]float32{ 0: Xcopysignf(tls, Float32FromInt32(1), x), 1: float32(float32(float32(float32(Float32FromInt32(4)*Xsinf(tls, y))*Xcosf(tls, y))*exp_mx) * exp_mx), } - return *(*complex64)(unsafe.Pointer(&v12)) + return *(*complex64)(unsafe.Pointer(&v1)) } t = Xtanf(tls, y) beta = float32(float64(1) + float64(t*t)) s = Xsinhf(tls, x) rho = Xsqrtf(tls, Float32FromInt32(1)+float32(s*s)) denom = Float32FromInt32(1) + float32(float32(beta*s)*s) - v13 = [2]float32{ + v1 = [2]float32{ 0: float32(float32(beta*rho)*s) / denom, 1: t / denom, } - return *(*complex64)(unsafe.Pointer(&v13)) + return *(*complex64)(unsafe.Pointer(&v1)) } // C documentation @@ -7418,13 +7418,13 @@ func Xsysconf(tls *TLS, name int32) (r int64) { bp := tls.Alloc(512) defer tls.Free(512) var cnt, i, v3 int32 - var mem, v1, v6 uint64 + var mem, v1 uint64 var val int64 - var p5 uintptr + var v5 uintptr var _ /* lim at bp+0 */ Trlimit var _ /* set at bp+16 */ [128]uint8 var _ /* si at bp+144 */ Tsysinfo - _, _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v6, p5 + _, _, _, _, _, _, _ = cnt, i, mem, val, v1, v3, v5 if Uint64FromInt32(name) >= Uint64FromInt64(502)/Uint64FromInt64(2) || !(_values1[name] != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return int64(-int32(1)) @@ -7480,14 +7480,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { goto _4 _4: ; - p5 = bp + 16 + uintptr(i) - *(*uint8)(unsafe.Pointer(p5)) = uint8(int32(*(*uint8)(unsafe.Pointer(p5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) - cnt++ + v5 = bp + 16 + uintptr(i) + *(*uint8)(unsafe.Pointer(v5)) = uint8(int32(*(*uint8)(unsafe.Pointer(v5))) & (Int32FromUint8((*(*[128]uint8)(unsafe.Pointer(bp + 16)))[i]) - Int32FromInt32(1))) + cnt = cnt + 1 } goto _2 _2: ; - i++ + i = i + 1 } return int64(cnt) case (-Int32FromInt32(256) | Int32FromInt32(8)) & Int32FromInt32(255): @@ -7502,14 +7502,14 @@ func Xsysconf(tls *TLS, name int32) (r int64) { } else { mem = (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Ffreeram + (*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fbufferram } - mem *= uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) - mem /= uint64(PAGESIZE) + mem = mem * uint64((*(*Tsysinfo)(unsafe.Pointer(bp + 144))).Fmem_unit) + mem = mem / uint64(PAGESIZE) if mem > uint64(0x7fffffffffffffff) { - v6 = uint64(0x7fffffffffffffff) + v1 = uint64(0x7fffffffffffffff) } else { - v6 = mem + v1 = mem } - return Int64FromUint64(v6) + return Int64FromUint64(v1) case (-Int32FromInt32(256) | Int32FromInt32(12)) & Int32FromInt32(255): fallthrough case (-Int32FromInt32(256) | Int32FromInt32(13)) & Int32FromInt32(255): @@ -7518,7 +7518,7 @@ func Xsysconf(tls *TLS, name int32) (r int64) { val = int64(MINSIGSTKSZ) } if int32(_values1[name]) == -Int32FromInt32(256)|Int32FromInt32(13) { - val += int64(Int32FromInt32(SIGSTKSZ) - Int32FromInt32(MINSIGSTKSZ)) + val = val + int64(Int32FromInt32(SIGSTKSZ)-Int32FromInt32(MINSIGSTKSZ)) } return val case (-Int32FromInt32(256) | Int32FromInt32(10)) & Int32FromInt32(255): @@ -8894,16 +8894,16 @@ var _BF_atoi64 = [96]uint8{ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { var c1, c2, c3, c4, tmp uint32 - var dptr, end, sptr, v1, v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1, v2, v3, v4, v5, v6, v7 + var dptr, end, sptr, v1 uintptr + _, _, _, _, _, _, _, _, _ = c1, c2, c3, c4, dptr, end, sptr, tmp, v1 dptr = dst end = dptr + uintptr(size) sptr = src for cond := true; cond; cond = dptr < end { v1 = sptr - sptr++ + sptr = sptr + 1 tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) - tmp -= uint32(0x20) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8912,10 +8912,10 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c1 = tmp - v2 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v2))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8924,16 +8924,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c2 = tmp - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(c1<>int32(4)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c1<>int32(4)) if dptr >= end { break } - v4 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v4))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8942,16 +8942,16 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c3 = tmp - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = uint8(c2&uint32(0x0F)<>int32(2)) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(c2&uint32(0x0F)<>int32(2)) if dptr >= end { break } - v6 = sptr - sptr++ - tmp = uint32(*(*uint8)(unsafe.Pointer(v6))) - tmp -= uint32(0x20) + v1 = sptr + sptr = sptr + 1 + tmp = uint32(*(*uint8)(unsafe.Pointer(v1))) + tmp = tmp - uint32(0x20) if tmp >= uint32(0x60) { return -int32(1) } @@ -8960,58 +8960,58 @@ func _BF_decode(tls *TLS, dst uintptr, src uintptr, size int32) (r int32) { return -int32(1) } c4 = tmp - v7 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v7)) = uint8(c3&uint32(0x03)<>int32(2)] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1>>int32(2)] c1 = c1 & uint32(0x03) << int32(4) if sptr >= end { - v3 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v3)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v4 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v4))) - c1 |= c2 >> int32(4) - v5 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v5)) = _BF_itoa64[c1] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(4) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] c1 = c2 & uint32(0x0f) << int32(2) if sptr >= end { - v6 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v6)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] break } - v7 = sptr - sptr++ - c2 = uint32(*(*uint8)(unsafe.Pointer(v7))) - c1 |= c2 >> int32(6) - v8 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v8)) = _BF_itoa64[c1] - v9 = dptr - dptr++ - *(*uint8)(unsafe.Pointer(v9)) = _BF_itoa64[c2&uint32(0x3f)] + v1 = sptr + sptr = sptr + 1 + c2 = uint32(*(*uint8)(unsafe.Pointer(v1))) + c1 = c1 | c2>>int32(6) + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c1] + v1 = dptr + dptr = dptr + 1 + *(*uint8)(unsafe.Pointer(v1)) = _BF_itoa64[c2&uint32(0x3f)] } } @@ -9031,7 +9031,7 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { goto _3 _3: ; - count-- + count = count - 1 v2 = count if !(v2 != 0) { break @@ -9042,12 +9042,12 @@ func _BF_swap(tls *TLS, x uintptr, count int32) { func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, end uintptr) (r TBF_word) { var i int32 - var ptr, v2, v3 uintptr + var ptr, v2 uintptr var tmp1, tmp2, tmp3, tmp4 TBF_word - _, _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2, v3 + _, _, _, _, _, _, _ = i, ptr, tmp1, tmp2, tmp3, tmp4, v2 ptr = start for cond := true; cond; cond = ptr < end { - L ^= *(*TBF_word)(unsafe.Pointer(ctx)) + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx)) i = 0 for { if !(i < int32(16)) { @@ -9055,36 +9055,36 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e } tmp1 = L & uint32(0xFF) tmp2 = L >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = L >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = L >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - R ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) - tmp3 += tmp1 - R ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + R = R ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1))*4)) + tmp3 = tmp3 + tmp1 + R = R ^ tmp3 tmp1 = R & uint32(0xFF) tmp2 = R >> int32(8) - tmp2 &= uint32(0xFF) + tmp2 = tmp2 & uint32(0xFF) tmp3 = R >> int32(16) - tmp3 &= uint32(0xFF) + tmp3 = tmp3 & uint32(0xFF) tmp4 = R >> int32(24) tmp1 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 3*1024 + uintptr(tmp1)*4)) tmp2 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 2*1024 + uintptr(tmp2)*4)) tmp3 = *(*TBF_word)(unsafe.Pointer(ctx + 72 + 1*1024 + uintptr(tmp3)*4)) - tmp3 += *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) - tmp3 ^= tmp2 - L ^= *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) - tmp3 += tmp1 - L ^= tmp3 + tmp3 = tmp3 + *(*TBF_word)(unsafe.Pointer(ctx + 72 + uintptr(tmp4)*4)) + tmp3 = tmp3 ^ tmp2 + L = L ^ *(*TBF_word)(unsafe.Pointer(ctx + uintptr(i+int32(1)+int32(1))*4)) + tmp3 = tmp3 + tmp1 + L = L ^ tmp3 goto _1 _1: ; - i += int32(2) + i = i + int32(2) } tmp4 = R R = L @@ -9092,9 +9092,9 @@ func _BF_encrypt(tls *TLS, ctx uintptr, L TBF_word, R TBF_word, start uintptr, e v2 = ptr ptr += 4 *(*TBF_word)(unsafe.Pointer(v2)) = L - v3 = ptr + v2 = ptr ptr += 4 - *(*TBF_word)(unsafe.Pointer(v3)) = R + *(*TBF_word)(unsafe.Pointer(v2)) = R } return L } @@ -9103,10 +9103,10 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags bp := tls.Alloc(16) defer tls.Free(16) var bug, i, j uint32 - var diff, safety, sign, v1, v3 TBF_word + var diff, safety, sign, v1 TBF_word var ptr uintptr var _ /* tmp at bp+0 */ [2]TBF_word - _, _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1, v3 + _, _, _, _, _, _, _, _ = bug, diff, i, j, ptr, safety, sign, v1 ptr = key /* * There was a sign extension bug in older revisions of this function. While @@ -9153,9 +9153,9 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags if !(i < Uint32FromInt32(Int32FromInt32(BF_N)+Int32FromInt32(2))) { break } - v3 = Uint32FromInt32(0) - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v3 - (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v3 + v1 = Uint32FromInt32(0) + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] = v1 + (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] = v1 j = uint32(0) for { if !(j < uint32(4)) { @@ -9172,25 +9172,25 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * extension in tmp[1] occurs. Once this flag is set, it remains set. */ if j != 0 { - sign |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] & uint32(0x80) + sign = sign | (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]&uint32(0x80) } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { ptr = key } else { - ptr++ + ptr = ptr + 1 } goto _4 _4: ; - j++ + j = j + 1 } - diff |= (*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)] /* Non-zero on any differences */ + diff = diff | ((*(*[2]TBF_word)(unsafe.Pointer(bp)))[0] ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[int32(1)]) /* Non-zero on any differences */ *(*TBF_word)(unsafe.Pointer(expanded + uintptr(i)*4)) = (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] *(*TBF_word)(unsafe.Pointer(initial + uintptr(i)*4)) = *(*TBF_word)(unsafe.Pointer(uintptr(unsafe.Pointer(&_BF_init_state)) + uintptr(i)*4)) ^ (*(*[2]TBF_word)(unsafe.Pointer(bp)))[bug] goto _2 _2: ; - i++ + i = i + 1 } /* * At this point, "diff" is zero iff the correct and buggy algorithms produced @@ -9201,11 +9201,11 @@ func _BF_set_key(tls *TLS, key uintptr, expanded uintptr, initial uintptr, flags * is meant to protect from such many-buggy to one-correct collisions, by * deviating from the correct algorithm in such cases. Let's check for this. */ - diff |= diff >> int32(16) /* still zero iff exact match */ - diff &= uint32(0xffff) /* ditto */ - diff += uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ - sign <<= uint32(9) /* move the non-benign sign extension flag to bit 16 */ - sign &= ^diff & safety /* action needed? */ + diff = diff | diff>>int32(16) /* still zero iff exact match */ + diff = diff & uint32(0xffff) /* ditto */ + diff = diff + uint32(0xffff) /* bit 16 set iff "diff" was non-zero (on non-match) */ + sign = sign << uint32(9) /* move the non-benign sign extension flag to bit 16 */ + sign = sign & (^diff & safety) /* action needed? */ /* * If we have determined that we need to deviate from the correct algorithm, * flip bit 16 in initial expanded key. (The choice of 16 is arbitrary, but @@ -9230,7 +9230,7 @@ var _flags_by_subtype = [26]uint8{ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_word) (r uintptr) { bp := tls.Alloc(4272) defer tls.Free(4272) - var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1, v6 TBF_word + var L, L1, R, count, tmp1, tmp2, tmp3, tmp4, v1 TBF_word var done, i int32 var ptr uintptr var _ /* LR at bp+4264 */ [2]TBF_word @@ -9243,7 +9243,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w F__ccgo_pad2 [8]byte } } - _, _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = L, L1, R, count, done, i, ptr, tmp1, tmp2, tmp3, tmp4, v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(setting))) != int32('$') || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 1))) != int32('2') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')) > uint32(25) || !(_flags_by_subtype[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 2)))-int32('a')] != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 3))) != int32('$') || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 4)))-int32('0')) > uint32(1) || Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 5)))-int32('0')) > uint32(9) || Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + 6))) != int32('$') { return UintptrFromInt32(0) } @@ -9260,13 +9260,13 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w for cond := true; cond; cond = int32(1) != 0 { L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 1*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 if ptr >= bp+uintptr(Int32FromInt32(BF_N)+Int32FromInt32(2)+Int32FromInt32(4)*Int32FromInt32(0x100))*4 { break } L = _BF_encrypt(tls, bp, L^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 2*4)), R^*(*TBF_word)(unsafe.Pointer(bp + 4240 + 3*4)), ptr, ptr) R = *(*TBF_word)(unsafe.Pointer(ptr + UintptrFromInt32(1)*4)) - ptr += uintptr(2) * 4 + ptr = ptr + uintptr(2)*4 } for { i = 0 @@ -9279,7 +9279,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _3 _3: ; - i += int32(2) + i = i + int32(2) } done = 0 for cond := true; cond; cond = int32(1) != 0 { @@ -9304,7 +9304,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _4 _4: ; - i += int32(4) + i = i + int32(4) } *(*TBF_word)(unsafe.Pointer(bp + 16*4)) ^= tmp1 *(*TBF_word)(unsafe.Pointer(bp + 17*4)) ^= tmp2 @@ -9312,7 +9312,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _2 _2: ; - count-- + count = count - 1 v1 = count if !(v1 != 0) { break @@ -9331,9 +9331,9 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _7 _7: ; - count-- - v6 = count - if !(v6 != 0) { + count = count - 1 + v1 = count + if !(v1 != 0) { break } } @@ -9342,7 +9342,7 @@ func _BF_crypt(tls *TLS, key uintptr, setting uintptr, output uintptr, min TBF_w goto _5 _5: ; - i += int32(2) + i = i + int32(2) } Xmemcpy(tls, output, setting, Uint64FromInt32(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1))) *(*uint8)(unsafe.Pointer(output + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))) = _BF_itoa64[Int32FromUint8(_BF_atoi64[Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(Int32FromInt32(7)+Int32FromInt32(22)-Int32FromInt32(1)))))-int32(0x20)])&int32(0x30)] @@ -11225,7 +11225,7 @@ func _ascii_to_bin(tls *TLS, ch int32) (r Tuint32_t) { retval = sch - (Int32FromUint8('a') - Int32FromInt32(38)) } } - retval &= int32(0x3f) + retval = retval & int32(0x3f) return Uint32FromInt32(retval) } @@ -11252,14 +11252,14 @@ func _setup_salt(tls *TLS, salt Tuint32_t) (r Tuint32_t) { break } if salt&saltbit != 0 { - saltbits |= obit + saltbits = saltbits | obit } - saltbit <<= uint32(1) - obit >>= uint32(1) + saltbit = saltbit << uint32(1) + obit = obit >> uint32(1) goto _1 _1: ; - i++ + i = i + 1 } return saltbits } @@ -11269,8 +11269,8 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { trc("tls=%v key=%v ekey=%v, (%v:)", tls, key, ekey, origin(2)) } var i, ibit, j, round, shifts uint32 - var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1, v4 Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1, v4 + var k0, k1, kl, kr, rawkey0, rawkey1, t0, t1, v1 Tuint32_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, ibit, j, k0, k1, kl, kr, rawkey0, rawkey1, round, shifts, t0, t1, v1 rawkey0 = uint32(*(*uint8)(unsafe.Pointer(key + 3))) | uint32(*(*uint8)(unsafe.Pointer(key + 2)))<>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) - ibit -= uint32(4) - k1 |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4)) + k0 = k0 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskl)) + uintptr(i+uint32(4))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) + k1 = k1 | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j)*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(4) + k1 = k1 | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(j+uint32(1))*64 + uintptr(rawkey0>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_key_perm_maskr)) + uintptr(i+uint32(8))*64 + uintptr(rawkey1>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } /* * Rotate subkeys and do compression permutation. @@ -11305,35 +11305,35 @@ func X__des_setkey(tls *TLS, key uintptr, ekey uintptr) { if !(round < uint32(16)) { break } - shifts += uint32(_key_shifts[round]) + shifts = shifts + uint32(_key_shifts[round]) t0 = k0<>(Uint32FromInt32(28)-shifts) t1 = k1<>(Uint32FromInt32(28)-shifts) - v4 = Uint32FromInt32(0) - kr = v4 - kl = v4 + v1 = Uint32FromInt32(0) + kr = v1 + kl = v1 ibit = uint32(25) i = uint32(0) for { if !(i < uint32(4)) { break } - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) - ibit -= uint32(4) - kl |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) - kr |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) - ibit -= uint32(3) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl0)) + uintptr(i)*32 + uintptr(t0>>ibit&uint32(7))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr0)) + uintptr(i)*32 + uintptr(t1>>ibit&uint32(7))*4)) + ibit = ibit - uint32(4) + kl = kl | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskl1)) + uintptr(i)*64 + uintptr(t0>>ibit&uint32(0xf))*4)) + kr = kr | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_comp_maskr1)) + uintptr(i)*64 + uintptr(t1>>ibit&uint32(0xf))*4)) + ibit = ibit - uint32(3) goto _5 _5: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(ekey + uintptr(round)*4)) = kl *(*Tuint32_t)(unsafe.Pointer(ekey + 64 + uintptr(round)*4)) = kr goto _3 _3: ; - round++ + round = round + 1 } } @@ -11346,10 +11346,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if __ccgo_strace { trc("tls=%v l_in=%v r_in=%v l_out=%v r_out=%v count=%v saltbits=%v ekey=%v, (%v:)", tls, l_in, r_in, l_out, r_out, count, saltbits, ekey, origin(2)) } - var f, l, lo, r, r48l, r48r, ro, v1, v3, v7 Tuint32_t + var f, l, lo, r, r48l, r48r, ro, v1 Tuint32_t var i, i1, ibit, ibit1, round, v4 uint32 - var kl, kr, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v3, v4, v5, v6, v7 + var kl, kr, v5 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, i1, ibit, ibit1, kl, kr, l, lo, r, r48l, r48r, ro, round, v1, v4, v5 /* * Do initial permutation (IP). */ @@ -11363,19 +11363,19 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui if !(i < uint32(8)) { break } - l |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) - r |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4)) + l = l | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskl)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) + r = r | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i)*64 + uintptr(l_in>>ibit&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ip_maskr)) + uintptr(i+uint32(8))*64 + uintptr(r_in>>ibit&uint32(0xf))*4))) goto _2 _2: ; - i++ - ibit -= uint32(4) + i = i + 1 + ibit = ibit - uint32(4) } } for { - v3 = count - count-- - if !(v3 != 0) { + v1 = count + count = count - 1 + if !(v1 != 0) { break } /* @@ -11386,7 +11386,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui kr = ekey + 64 for { v4 = round - round-- + round = round - 1 if !(v4 != 0) { break } @@ -11402,10 +11402,10 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui f = (r48l ^ r48r) & saltbits v5 = kl kl += 4 - r48l ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v5)) - v6 = kr + r48l = r48l ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) + v5 = kr kr += 4 - r48r ^= f ^ *(*Tuint32_t)(unsafe.Pointer(v6)) + r48r = r48r ^ (f ^ *(*Tuint32_t)(unsafe.Pointer(v5))) /* * Do S-box lookups (which shrink it back to 32 bits) * and do the P-box permutation at the same time. @@ -11414,7 +11414,7 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Now that we've permuted things, complete f(). */ - f ^= l + f = f ^ l l = r r = f } @@ -11424,23 +11424,23 @@ func X__do_des(tls *TLS, l_in Tuint32_t, r_in Tuint32_t, l_out uintptr, r_out ui /* * Do final permutation (inverse of IP). */ - v7 = Uint32FromInt32(0) - ro = v7 - lo = v7 + v1 = Uint32FromInt32(0) + ro = v1 + lo = v1 i1 = uint32(0) ibit1 = Uint32FromInt32(28) for { if !(i1 < uint32(4)) { break } - ro |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) - ibit1 -= uint32(4) - lo |= *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4)) + ro = ro | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskr)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) + ibit1 = ibit1 - uint32(4) + lo = lo | (*(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1)*64 + uintptr(l>>ibit1&uint32(0xf))*4)) | *(*Tuint32_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&_fp_maskl)) + uintptr(i1+uint32(4))*64 + uintptr(r>>ibit1&uint32(0xf))*4))) goto _8 _8: ; - i1++ - ibit1 -= uint32(4) + i1 = i1 + 1 + ibit1 = ibit1 - uint32(4) } *(*Tuint32_t)(unsafe.Pointer(l_out)) = lo *(*Tuint32_t)(unsafe.Pointer(r_out)) = ro @@ -11471,12 +11471,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin defer tls.Free(144) var count, l, salt, value, value1 Tuint32_t var i uint32 - var key, p, q, setting, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 uintptr + var key, p, q, setting, v1, v4, v5 uintptr var _ /* ekey at bp+0 */ Texpanded_key var _ /* keybuf at bp+128 */ [8]uint8 var _ /* r0 at bp+136 */ Tuint32_t var _ /* r1 at bp+140 */ Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v10, v11, v12, v13, v14, v15, v16, v17, v5, v6, v7, v8, v9, p4 + _, _, _, _, _, _, _, _, _, _, _, _, _ = count, i, key, l, p, q, salt, setting, value, value1, v1, v4, v5 key = _key setting = _setting /* @@ -11486,10 +11486,10 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) { v1 = q - q++ + q = q + 1 *(*uint8)(unsafe.Pointer(v1)) = Uint8FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key))) << int32(1)) if *(*uint8)(unsafe.Pointer(key)) != 0 { - key++ + key = key + 1 } } X__des_setkey(tls, bp+128, bp) @@ -11509,11 +11509,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - count |= value << ((i - uint32(1)) * uint32(6)) + count = count | value<<((i-uint32(1))*uint32(6)) goto _2 _2: ; - i++ + i = i + 1 } if !(count != 0) { return UintptrFromInt32(0) @@ -11528,11 +11528,11 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin if Int32FromUint8(_ascii64[value1]) != Int32FromUint8(*(*uint8)(unsafe.Pointer(setting + uintptr(i)))) { return UintptrFromInt32(0) } - salt |= value1 << ((i - uint32(5)) * uint32(6)) + salt = salt | value1<<((i-uint32(5))*uint32(6)) goto _3 _3: ; - i++ + i = i + 1 } for *(*uint8)(unsafe.Pointer(key)) != 0 { /* @@ -11544,12 +11544,12 @@ func __crypt_extended_r_uut(tls *TLS, _key uintptr, _setting uintptr, output uin */ q = bp + 128 for q <= bp+128+uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) && *(*uint8)(unsafe.Pointer(key)) != 0 { - v5 = q - q++ - p4 = v5 - v6 = key - key++ - *(*uint8)(unsafe.Pointer(p4)) = uint8(int32(*(*uint8)(unsafe.Pointer(p4))) ^ Int32FromUint8(*(*uint8)(unsafe.Pointer(v6)))<> int32(8) - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v7)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v10 = p - p++ - *(*uint8)(unsafe.Pointer(v10)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 136))<>Int32FromInt32(16)&uint32(0xffff) - v11 = p - p++ - *(*uint8)(unsafe.Pointer(v11)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] - v12 = p - p++ - *(*uint8)(unsafe.Pointer(v12)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v13 = p - p++ - *(*uint8)(unsafe.Pointer(v13)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v14 = p - p++ - *(*uint8)(unsafe.Pointer(v14)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(18)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] l = *(*Tuint32_t)(unsafe.Pointer(bp + 140)) << int32(2) - v15 = p - p++ - *(*uint8)(unsafe.Pointer(v15)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] - v16 = p - p++ - *(*uint8)(unsafe.Pointer(v16)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] - v17 = p - p++ - *(*uint8)(unsafe.Pointer(v17)) = _ascii64[l&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(12)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l>>Int32FromInt32(6)&uint32(0x3f)] + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = _ascii64[l&uint32(0x3f)] *(*uint8)(unsafe.Pointer(p)) = uint8(0) return output } @@ -11758,7 +11758,7 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -11766,60 +11766,60 @@ func _processblock(tls *TLS, s uintptr, buf uintptr) { d = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 3*4)) i = uint32(0) for i < uint32(16) { - a += d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + a = a + (d ^ b&(c^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) a = _rol(tls, a, int32(7)) + b - i++ - d += c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + d = d + (c ^ a&(b^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) d = _rol(tls, d, int32(12)) + a - i++ - c += b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + c = c + (b ^ d&(a^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) c = _rol(tls, c, int32(17)) + d - i++ - b += a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i] + i = i + 1 + b = b + (a ^ c&(d^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[i] + _tab[i]) b = _rol(tls, b, int32(22)) + c - i++ + i = i + 1 } for i < uint32(32) { - a += c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + a = a + (c ^ d&(c^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(5)) + b - i++ - d += b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ c&(b^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(9)) + a - i++ - c += a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ b&(a^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(14)) + d - i++ - b += d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ a&(d^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(5)*i+uint32(1))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(20)) + c - i++ + i = i + 1 } for i < uint32(48) { - a += b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + a = a + (b ^ c ^ d + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(4)) + b - i++ - d += a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + d = d + (a ^ b ^ c + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(11)) + a - i++ - c += d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + c = c + (d ^ a ^ b + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(16)) + d - i++ - b += c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i] + i = i + 1 + b = b + (c ^ d ^ a + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[(uint32(3)*i+uint32(5))%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(23)) + c - i++ + i = i + 1 } for i < uint32(64) { - a += c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + a = a + (c ^ (b | ^d) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) a = _rol(tls, a, int32(6)) + b - i++ - d += b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + d = d + (b ^ (a | ^c) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) d = _rol(tls, d, int32(10)) + a - i++ - c += a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + c = c + (a ^ (d | ^b) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) c = _rol(tls, c, int32(15)) + d - i++ - b += d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i] + i = i + 1 + b = b + (d ^ (c | ^a) + (*(*[16]Tuint32_t)(unsafe.Pointer(bp)))[uint32(7)*i%uint32(16)] + _tab[i]) b = _rol(tls, b, int32(21)) + c - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -11832,7 +11832,7 @@ func _pad(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tmd5)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 24 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+24+uintptr(r), 0, uint64(uint32(64)-r)) @@ -11876,7 +11876,7 @@ func _md5_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -11893,8 +11893,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+24+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock(tls, s, s+24) } for { @@ -11905,8 +11905,8 @@ func _md5_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+24, p, len1) } @@ -11946,15 +11946,15 @@ func _to64(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b64[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -11985,7 +11985,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _1 _1: ; - i++ + i = i + 1 } slen = i /* md5(key salt key) */ @@ -12024,7 +12024,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _md5_sum(tls, bp, bp+88) /* md = f(md, key, salt) iteration */ @@ -12054,13 +12054,13 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _4 _4: ; - i++ + i = i + 1 } /* output is $1$salt$hash */ Xmemcpy(tls, output, setting, uint64(uint32(3)+slen)) p = output + uintptr(3) + uintptr(slen) v5 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v5)) = uint8('$') i = uint32(0) for { @@ -12071,7 +12071,7 @@ func _md5crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r uintpt goto _6 _6: ; - i++ + i = i + 1 } p = _to64(tls, p, uint32((*(*[16]uint8)(unsafe.Pointer(bp + 88)))[int32(11)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -12271,7 +12271,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _1 _1: ; - i++ + i = i + 1 } for { if !(i < int32(64)) { @@ -12281,7 +12281,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _2 _2: ; - i++ + i = i + 1 } a = *(*Tuint32_t)(unsafe.Pointer(s + 8)) b = *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) @@ -12309,7 +12309,7 @@ func _processblock1(tls *TLS, s uintptr, buf uintptr) { goto _3 _3: ; - i++ + i = i + 1 } *(*Tuint32_t)(unsafe.Pointer(s + 8)) += a *(*Tuint32_t)(unsafe.Pointer(s + 8 + 1*4)) += b @@ -12326,7 +12326,7 @@ func _pad1(tls *TLS, s uintptr) { _, _ = r, v1 r = uint32((*Tsha256)(unsafe.Pointer(s)).Flen1 % uint64(64)) v1 = r - r++ + r = r + 1 *(*Tuint8_t)(unsafe.Pointer(s + 40 + uintptr(v1))) = uint8(0x80) if r > uint32(56) { Xmemset(tls, s+40+uintptr(r), 0, uint64(uint32(64)-r)) @@ -12374,7 +12374,7 @@ func _sha256_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12391,8 +12391,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+40+uintptr(r), p, uint64(uint32(64)-r)) - len1 -= uint64(uint32(64) - r) - p += uintptr(uint32(64) - r) + len1 = len1 - uint64(uint32(64)-r) + p = p + uintptr(uint32(64)-r) _processblock1(tls, s, s+40) } for { @@ -12403,8 +12403,8 @@ func _sha256_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(64) - p += uintptr(64) + len1 = len1 - uint64(64) + p = p + uintptr(64) } Xmemcpy(tls, s+40, p, len1) } @@ -12416,15 +12416,15 @@ func _to641(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b641[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -12448,7 +12448,7 @@ func _hashmd(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(32) + i = i - uint32(32) } _sha256_update(tls, s, md, uint64(i)) } @@ -12491,7 +12491,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -12524,7 +12524,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -12551,7 +12551,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha256_sum(tls, bp, bp+104) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -12565,7 +12565,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+136) /* DS = sha(repeat-salt) */ @@ -12579,7 +12579,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha256_sum(tls, bp, bp+168) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -12609,11 +12609,11 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } /* output is $5$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+170, VaList(bp+240, bp+200, slen, salt))) i = uint32(0) for { if !(i < uint32(10)) { @@ -12623,7 +12623,7 @@ func _sha256crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } p = _to641(tls, p, Uint32FromInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp + 104)))[int32(31)])< uint32(112) { Xmemset(tls, s+72+uintptr(r), 0, uint64(uint32(128)-r)) @@ -12933,7 +12933,7 @@ func _sha512_sum(tls *TLS, s uintptr, md uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -12950,8 +12950,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { return } Xmemcpy(tls, s+72+uintptr(r), p, uint64(uint32(128)-r)) - len1 -= uint64(uint32(128) - r) - p += uintptr(uint32(128) - r) + len1 = len1 - uint64(uint32(128)-r) + p = p + uintptr(uint32(128)-r) _processblock2(tls, s, s+72) } for { @@ -12962,8 +12962,8 @@ func _sha512_update(tls *TLS, s uintptr, m uintptr, len1 uint64) { goto _1 _1: ; - len1 -= uint64(128) - p += uintptr(128) + len1 = len1 - uint64(128) + p = p + uintptr(128) } Xmemcpy(tls, s+72, p, len1) } @@ -12975,15 +12975,15 @@ func _to642(tls *TLS, s uintptr, u uint32, n int32) (r uintptr) { var v2 uintptr _, _ = v1, v2 for { - n-- + n = n - 1 v1 = n if !(v1 >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _b642[u%uint32(64)] - u /= uint32(64) + u = u / uint32(64) } return s } @@ -13007,7 +13007,7 @@ func _hashmd1(tls *TLS, s uintptr, n uint32, md uintptr) { goto _1 _1: ; - i -= uint32(64) + i = i - uint32(64) } _sha512_update(tls, s, md, uint64(i)) } @@ -13035,7 +13035,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _1 _1: ; - i++ + i = i + 1 } if i > uint32(KEY_MAX1) { return uintptr(0) @@ -13060,7 +13060,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui * including non-portable hashes that depend on * the host's value of ULONG_MAX. */ - salt += uintptr(Uint64FromInt64(8) - Uint64FromInt32(1)) + salt = salt + uintptr(Uint64FromInt64(8)-Uint64FromInt32(1)) if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(salt)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } @@ -13093,7 +13093,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _2 _2: ; - i++ + i = i + 1 } slen = i /* B = sha(key salt key) */ @@ -13120,7 +13120,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _3 _3: ; - i >>= uint32(1) + i = i >> uint32(1) } _sha512_sum(tls, bp, bp+200) /* DP = sha(repeat-key), this step takes O(klen^2) time */ @@ -13134,7 +13134,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _4 _4: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+264) /* DS = sha(repeat-salt) */ @@ -13148,7 +13148,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _5 _5: ; - i++ + i = i + 1 } _sha512_sum(tls, bp, bp+328) /* iterate A = f(A,DP,DS), this step takes O(rounds*klen) time */ @@ -13178,11 +13178,11 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _6 _6: ; - i++ + i = i + 1 } /* output is $6$rounds=n$salt$hash */ p = output - p += uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) + p = p + uintptr(Xsprintf(tls, p, __ccgo_ts+185, VaList(bp+432, bp+392, slen, salt))) i = uint32(0) for { if !(i < uint32(21)) { @@ -13192,7 +13192,7 @@ func _sha512crypt(tls *TLS, key uintptr, setting uintptr, output uintptr) (r1 ui goto _7 _7: ; - i++ + i = i + 1 } p = _to642(tls, p, uint32((*(*[64]uint8)(unsafe.Pointer(bp + 200)))[int32(63)]), int32(2)) *(*uint8)(unsafe.Pointer(p)) = uint8(0) @@ -13340,9 +13340,9 @@ func Xsetkey(tls *TLS, key uintptr) { bp := tls.Alloc(16) defer tls.Free(16) var i, j int32 - var p3 uintptr + var v3 uintptr var _ /* bkey at bp+0 */ [8]uint8 - _, _, _ = i, j, p3 + _, _, _ = i, j, v3 i = 0 for { if !(i < int32(8)) { @@ -13354,18 +13354,18 @@ func Xsetkey(tls *TLS, key uintptr) { if !(j >= 0) { break } - p3 = bp + uintptr(i) - *(*uint8)(unsafe.Pointer(p3)) = uint8(uint32(*(*uint8)(unsafe.Pointer(p3))) | Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(key)))&Int32FromInt32(1))<> j & uint32(1)) goto _5 _5: ; - j-- + j = j - 1 } goto _4 _4: ; - i++ + i = i + 1 } } @@ -17483,8 +17483,8 @@ func Xwctype(tls *TLS, s uintptr) (r Twctype_t) { goto _1 _1: ; - i++ - p += uintptr(6) + i = i + 1 + p = p + uintptr(6) } return uint64(0) } @@ -22201,7 +22201,7 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return Int32FromUint32(c) } b = c >> int32(8) - c &= uint32(255) + c = c & uint32(255) x = c / uint32(3) y = c % uint32(3) /* lookup entry in two-level base-6 table */ @@ -22240,10 +22240,10 @@ func _casemap(tls *TLS, c uint32, dir int32) (r1 int32) { return c0 + v1 } else { if try > c { - xn /= uint32(2) + xn = xn / uint32(2) } else { - xb += xn / uint32(2) - xn -= xn / uint32(2) + xb = xb + xn/uint32(2) + xn = xn - xn/uint32(2) } } } @@ -22309,15 +22309,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { trc("tls=%v wcs=%v n=%v, (%v:)", tls, wcs, n, origin(2)) defer func() { trc("-> %v", r) }() } - var k, l, v3, v5 int32 + var k, l, v3 int32 var v2 Tsize_t var v4 bool - _, _, _, _, _, _ = k, l, v2, v3, v4, v5 + _, _, _, _, _ = k, l, v2, v3, v4 l = 0 k = 0 for { v2 = n - n-- + n = n - 1 if v4 = v2 != 0 && *(*Twchar_t)(unsafe.Pointer(wcs)) != 0; v4 { v3 = Xwcwidth(tls, *(*Twchar_t)(unsafe.Pointer(wcs))) k = v3 @@ -22328,15 +22328,15 @@ func Xwcswidth(tls *TLS, wcs uintptr, n Tsize_t) (r int32) { goto _1 _1: ; - l += k + l = l + k wcs += 4 } if k < 0 { - v5 = k + v3 = k } else { - v5 = l + v3 = l } - return v5 + return v3 } func Xwctrans(tls *TLS, class uintptr) (r Twctrans_t) { @@ -24891,10 +24891,10 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo trc("tls=%v path=%v res=%v __ccgo_fp_sel=%v __ccgo_fp_cmp=%v, (%v:)", tls, path, res, __ccgo_fp_sel, __ccgo_fp_cmp, origin(2)) defer func() { trc("-> %v", r) }() } - var cnt, len1, v2, v3 Tsize_t + var cnt, len1, v2 Tsize_t var d, de, names, tmp, v1 uintptr var old_errno int32 - _, _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2, v3 + _, _, _, _, _, _, _, _, _ = cnt, d, de, len1, names, old_errno, tmp, v1, v2 d = Xopendir(tls, path) names = uintptr(0) cnt = uint64(0) @@ -24929,16 +24929,16 @@ func Xscandir(tls *TLS, path uintptr, res uintptr, __ccgo_fp_sel uintptr, __ccgo break } v2 = cnt - cnt++ + cnt = cnt + 1 Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(v2)*8)), de, uint64((*Tdirent)(unsafe.Pointer(de)).Fd_reclen)) } Xclosedir(tls, d) if *(*int32)(unsafe.Pointer(X__errno_location(tls))) != 0 { if names != 0 { for { - v3 = cnt - cnt-- - if !(v3 > uint64(0)) { + v2 = cnt + cnt = cnt - 1 + if !(v2 > uint64(0)) { break } Xfree(tls, *(*uintptr)(unsafe.Pointer(names + uintptr(cnt)*8))) @@ -25008,7 +25008,7 @@ func X__reset_tls(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 p = (*Ttls_module)(unsafe.Pointer(p)).Fnext } } @@ -25128,7 +25128,7 @@ func X__putenv(tls *TLS, s uintptr, l Tsize_t, r uintptr) (r1 int32) { _1: ; e += 8 - i++ + i = i + 1 } } if Xenviron == _oldenv { @@ -25230,7 +25230,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if !(new1 != 0) { return @@ -25242,7 +25242,7 @@ func X__env_rm_add(tls *TLS, old uintptr, new1 uintptr) { v2 = t _env_alloced = v2 v3 = _env_alloced_n - _env_alloced_n++ + _env_alloced_n = _env_alloced_n + 1 *(*uintptr)(unsafe.Pointer(v2 + uintptr(v3)*8)) = new1 } @@ -25687,7 +25687,7 @@ func X__funcs_on_quick_exit(tls *TLS) { _, _ = func1, v1 ___lock(tls, uintptr(unsafe.Pointer(&_lock))) for _count > 0 { - _count-- + _count = _count - 1 v1 = _count func1 = _funcs[v1] ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25711,7 +25711,7 @@ func Xat_quick_exit(tls *TLS, __ccgo_fp_func uintptr) (r1 int32) { r = -int32(1) } else { v1 = _count - _count++ + _count = _count + 1 _funcs[v1] = __ccgo_fp_func } ___unlock(tls, uintptr(unsafe.Pointer(&_lock))) @@ -25755,7 +25755,7 @@ func Xfcntl(tls *TLS, fd int32, cmd int32, va uintptr) (r int32) { arg = VaUint64(&ap) _ = ap if cmd == int32(F_SETFL) { - arg |= uint64(O_LARGEFILE) + arg = arg | uint64(O_LARGEFILE) } if cmd == int32(F_SETLKW) { return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_fcntl), int64(fd), int64(cmd), int64(uintptr(arg)), 0, 0, 0)))) @@ -25899,7 +25899,7 @@ func Xfeclearexcept(tls *TLS, mask int32) (r int32) { trc("tls=%v mask=%v, (%v:)", tls, mask, origin(2)) defer func() { trc("-> %v", r) }() } - mask &= int32(FE_ALL_EXCEPT) + mask = mask & int32(FE_ALL_EXCEPT) _set_fpc(tls, _get_fpc(tls)&Uint32FromInt32(^mask)) return 0 } @@ -25909,7 +25909,7 @@ func Xferaiseexcept(tls *TLS, mask int32) (r int32) { trc("tls=%v mask=%v, (%v:)", tls, mask, origin(2)) defer func() { trc("-> %v", r) }() } - mask &= int32(FE_ALL_EXCEPT) + mask = mask & int32(FE_ALL_EXCEPT) _set_fpc(tls, _get_fpc(tls)|Uint32FromInt32(mask)) return 0 } @@ -26032,15 +26032,15 @@ type TFILE = struct { type T_IO_FILE = TFILE func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { - var c, neg, x, v1, v10, v14, v18, v4 int32 - var y, v22 int64 - var v11, v12, v15, v16, v19, v2, v20, v3, v5, v6 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v10, v11, v12, v14, v15, v16, v18, v19, v2, v20, v22, v3, v4, v5, v6 + var c, neg, x, v1 int32 + var y, v19 int64 + var v2, v3 uintptr + _, _, _, _, _, _, _, _ = c, neg, x, y, v1, v19, v2, v3 neg = 0 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26049,23 +26049,23 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { if c == int32('+') || c == int32('-') { neg = BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v6 = f + 8 - v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v4 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v4 + c = v1 if Uint32FromInt32(c-int32('0')) >= uint32(10) && pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } if Uint32FromInt32(c-int32('0')) >= uint32(10) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return -Int64FromInt64(0x7fffffffffffffff) - Int64FromInt32(1) } @@ -26075,18 +26075,18 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } x = int32(10)*x + c - int32('0') - goto _9 - _9: + goto _7 + _7: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v12 = f + 8 - v11 = *(*uintptr)(unsafe.Pointer(v12)) - *(*uintptr)(unsafe.Pointer(v12))++ - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v10 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v10 + c = v1 } y = int64(x) for { @@ -26094,58 +26094,58 @@ func _scanexp(tls *TLS, f uintptr, pok int32) (r int64) { break } y = int64(10)*y + int64(c) - int64('0') - goto _13 - _13: + goto _11 + _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 } for { if !(Uint32FromInt32(c-int32('0')) < uint32(10)) { break } - goto _17 - _17: + goto _15 + _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v20 = f + 8 - v19 = *(*uintptr)(unsafe.Pointer(v20)) - *(*uintptr)(unsafe.Pointer(v20))++ - v18 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v18 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v18 + c = v1 } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if neg != 0 { - v22 = -y + v19 = -y } else { - v22 = y + v19 = y } - return v22 + return v19 } func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, pok int32) (r float64) { bp := tls.Alloc(512) defer tls.Free(512) - var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v13, v14, v2, v21, v23, v29, v30, v6, v9 int32 + var a, bitlim, denormal, e2, emax, gotdig, gotrad, i, j, k, lnz, p10, rp, rpm9, sh, z, v2, v6 int32 var bias, frac, y float64 var carry, carry1, carry2, t, tmp, tmp2 Tuint32_t var dc, e10, lrp int64 var tmp1 Tuint64_t - var v10, v11, v15, v16, v3, v4, v7, v8 uintptr + var v3, v4 uintptr var _ /* x at bp+0 */ [128]Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v10, v11, v13, v14, v15, v16, v2, v21, v23, v29, v3, v30, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, bias, bitlim, carry, carry1, carry2, dc, denormal, e10, e2, emax, frac, gotdig, gotrad, i, j, k, lnz, lrp, p10, rp, rpm9, sh, t, tmp, tmp1, tmp2, y, z, v2, v3, v4, v6 lrp = 0 dc = 0 e10 = 0 @@ -26170,7 +26170,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26180,32 +26180,32 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v8 = f + 8 - v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v7))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v6 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v6 + c = v2 for { if !(c == int32('0')) { break } gotdig = int32(1) - lrp-- + lrp = lrp - 1 goto _5 _5: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v11 = f + 8 - v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v9 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v9 + c = v2 } } (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[0] = uint32(0) @@ -26221,7 +26221,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, lrp = dc } else { if k < Int32FromInt32(KMAX)-Int32FromInt32(3) { - dc++ + dc = dc + 1 if c != int32('0') { lnz = int32(dc) } @@ -26230,15 +26230,15 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } else { (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] = Uint32FromInt32(c - int32('0')) } - j++ - v13 = j - if v13 == int32(9) { - k++ + j = j + 1 + v2 = j + if v2 == int32(9) { + k = k + 1 j = 0 } gotdig = int32(1) } else { - dc++ + dc = dc + 1 if c != int32('0') { lnz = (Int32FromInt32(KMAX) - Int32FromInt32(4)) * Int32FromInt32(9) *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(Int32FromInt32(KMAX)-Int32FromInt32(4))*4)) |= uint32(1) @@ -26249,14 +26249,14 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, _12: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v2 = X__shgetc(tls, f) } - c = v14 + c = v2 } if !(gotrad != 0) { lrp = dc @@ -26266,7 +26266,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if e10 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26274,11 +26274,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, } e10 = 0 } - lrp += e10 + lrp = lrp + e10 } else { if c >= 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } @@ -26310,12 +26310,12 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, break } *(*Tuint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32(10) - goto _19 - _19: + goto _17 + _17: ; - j++ + j = j + 1 } - k++ + k = k + 1 j = 0 } a = 0 @@ -26340,19 +26340,19 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if !!((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[z-int32(1)] != 0) { break } - goto _20 - _20: + goto _18 + _18: ; - z-- + z = z - 1 } /* Align radix point to B1B digit boundary */ if rp%int32(9) != 0 { if rp >= 0 { - v21 = rp % int32(9) + v2 = rp % int32(9) } else { - v21 = rp%int32(9) + int32(9) + v2 = rp%int32(9) + int32(9) } - rpm9 = v21 + rpm9 = v2 p10 = _p10s[int32(8)-rpm9] carry = uint32(0) k = a @@ -26365,24 +26365,24 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry = Uint32FromInt32(int32(1000000000)/p10) * tmp if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - rp -= int32(9) + rp = rp - int32(9) } - goto _22 - _22: + goto _20 + _20: ; - k++ + k = k + 1 } if carry != 0 { - v23 = z - z++ - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v23] = carry + v2 = z + z = z + 1 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v2] = carry } - rp += int32(9) - rpm9 + rp = rp + (int32(9) - rpm9) } /* Upscale until desired number of bits are left of radix point */ for rp < Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) || rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) && (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[a] < _th[0] { carry1 = uint32(0) - e2 -= int32(29) + e2 = e2 - int32(29) k = (z - int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) for { tmp1 = uint64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k])< _th[i] { break } - goto _26 - _26: + goto _24 + _24: ; - i++ + i = i + 1 } if i == int32(LD_B1B_DIG) && rp == Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { break @@ -26443,7 +26443,7 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if rp > Int32FromInt32(9)+Int32FromInt32(9)*Int32FromInt32(LD_B1B_DIG) { sh = int32(9) } - e2 += sh + e2 = e2 + sh k = a for { if !(k != z) { @@ -26454,11 +26454,11 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, carry2 = Uint32FromInt32(Int32FromInt32(1000000000)>>sh) * tmp2 if k == a && !((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[k] != 0) { a = (a + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - i-- - rp -= int32(9) + i = i - 1 + rp = rp - int32(9) } - goto _27 - _27: + goto _25 + _25: ; k = (k + int32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) } @@ -26470,29 +26470,29 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, *(*Tuint32_t)(unsafe.Pointer(bp + uintptr((z-int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)))*4)) |= uint32(1) } } - goto _25 - _25: + goto _23 + _23: } /* Assemble desired bits into floating point variable */ - v29 = Int32FromInt32(0) - i = v29 - y = float64(v29) + v2 = Int32FromInt32(0) + i = v2 + y = float64(v2) for { if !(i < int32(LD_B1B_DIG)) { break } if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - v30 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) - z = v30 - (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v30-int32(1)] = uint32(0) + v6 = (z + Int32FromInt32(1)) & (Int32FromInt32(KMAX) - Int32FromInt32(1)) + z = v6 + (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[v6-int32(1)] = uint32(0) } y = float64(Float64FromFloat64(1e+09)*y) + float64((*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))]) - goto _28 - _28: + goto _26 + _26: ; - i++ + i = i + 1 } - y *= float64(sign) + y = y * float64(sign) /* Limit precision for denormal results */ if bits > int32(LDBL_MANT_DIG)+e2-emin { bits = int32(LDBL_MANT_DIG) + e2 - emin @@ -26505,40 +26505,40 @@ func _decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32, if bits < int32(LDBL_MANT_DIG) { bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(2)*Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), y) frac = Xfmodl(tls, y, Xscalbn(tls, Float64FromInt32(1), int32(LDBL_MANT_DIG)-bits)) - y -= frac - y += bias + y = y - frac + y = y + bias } /* Process tail of decimal input so it can affect rounding */ if (a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z { t = (*(*[128]Tuint32_t)(unsafe.Pointer(bp)))[(a+i)&(Int32FromInt32(KMAX)-Int32FromInt32(1))] if t < uint32(500000000) && (t != 0 || (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) != z) { - frac += float64(float64(0.25) * float64(sign)) + frac = frac + float64(float64(0.25)*float64(sign)) } else { if t > uint32(500000000) { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } else { if t == uint32(500000000) { if (a+i+int32(1))&(Int32FromInt32(KMAX)-Int32FromInt32(1)) == z { - frac += float64(float64(0.5) * float64(sign)) + frac = frac + float64(float64(0.5)*float64(sign)) } else { - frac += float64(float64(0.75) * float64(sign)) + frac = frac + float64(float64(0.75)*float64(sign)) } } } } if int32(LDBL_MANT_DIG)-bits >= int32(2) && !(Xfmodl(tls, frac, Float64FromInt32(1)) != 0) { - frac++ + frac = frac + 1 } } - y += frac - y -= bias + y = y + frac + y = y - bias if (e2+int32(LDBL_MANT_DIG))&int32(INT_MAX) > emax-int32(5) { if Xfabsl(tls, y) >= Float64FromInt32(2)/Float64FromFloat64(2.22044604925031308085e-16) { if denormal != 0 && bits == int32(LDBL_MANT_DIG)+e2-emin { denormal = 0 } - y *= Float64FromFloat64(0.5) - e2++ + y = y * Float64FromFloat64(0.5) + e2 = e2 + 1 } if e2+int32(LDBL_MANT_DIG) > emax || denormal != 0 && frac != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) @@ -26565,11 +26565,11 @@ var _p10s = [8]int32{ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32) (r float64) { var bias, scale, y float64 - var c, d, gotdig, gotrad, gottail, v1, v12, v16, v5, v8 int32 + var c, d, gotdig, gotrad, gottail, v1 int32 var dc, e2, rp int64 var x Tuint32_t - var v10, v13, v14, v17, v18, v2, v3, v6, v7, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v10, v12, v13, v14, v16, v17, v18, v2, v3, v5, v6, v7, v8, v9 + var v2, v3 uintptr + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bias, c, d, dc, e2, gotdig, gotrad, gottail, rp, scale, x, y, v1, v2, v3 x = uint32(0) y = Float64FromInt32(0) scale = Float64FromInt32(1) @@ -26583,7 +26583,7 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__shgetc(tls, f) @@ -26599,26 +26599,26 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _4: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v7 = f + 8 - v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v5 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v5 + c = v1 } if c == int32('.') { gotrad = int32(1) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 /* Count zeros after the radix point before significand */ rp = 0 for { @@ -26630,15 +26630,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 _11: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 - rp-- + c = v1 + rp = rp - 1 } } for { @@ -26662,41 +26662,41 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 x = x*uint32(16) + Uint32FromInt32(d) } else { if dc < int64(Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)+Int32FromInt32(1)) { - scale /= Float64FromInt32(16) - y += float64(float64(d) * scale) + scale = scale / Float64FromInt32(16) + y = y + float64(float64(d)*scale) } else { if d != 0 && !(gottail != 0) { - y += float64(Float64FromFloat64(0.5) * scale) + y = y + float64(Float64FromFloat64(0.5)*scale) gottail = int32(1) } } } - dc++ + dc = dc + 1 } goto _15 _15: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v18 = f + 8 - v17 = *(*uintptr)(unsafe.Pointer(v18)) - *(*uintptr)(unsafe.Pointer(v18))++ - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) + v3 = f + 8 + v2 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { - v16 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v16 + c = v1 } if !(gotdig != 0) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if gotrad != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } } else { @@ -26708,15 +26708,15 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 rp = dc } for dc < int64(8) { - x *= uint32(16) - dc++ + x = x * uint32(16) + dc = dc + 1 } if c|int32(32) == int32('p') { e2 = _scanexp(tls, f, pok) if e2 == -Int64FromInt64(0x7fffffffffffffff)-Int64FromInt32(1) { if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26726,10 +26726,10 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } } else { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } - e2 += int64(4)*rp - int64(32) + e2 = e2 + (int64(4)*rp - int64(32)) if !(x != 0) { return float64(float64(sign) * float64(0)) } @@ -26743,13 +26743,13 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 } for x < uint32(0x80000000) { if y >= Float64FromFloat64(0.5) { - x += x + uint32(1) - y += y - Float64FromInt32(1) + x = x + (x + uint32(1)) + y = y + (y - Float64FromInt32(1)) } else { - x += x - y += y + x = x + x + y = y + y } - e2-- + e2 = e2 - 1 } if int64(bits) > int64(32)+e2-int64(emin) { bits = int32(int64(32) + e2 - int64(emin)) @@ -26761,11 +26761,11 @@ func _hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int3 bias = Xcopysignl(tls, Xscalbn(tls, Float64FromInt32(1), Int32FromInt32(32)+Int32FromInt32(LDBL_MANT_DIG)-bits-int32(1)), float64(sign)) } if bits < int32(32) && y != 0 && !(x&Uint32FromInt32(1) != 0) { - x++ + x = x + 1 y = Float64FromInt32(0) } y = bias + float64(float64(sign)*float64(x)) + float64(float64(sign)*y) - y -= bias + y = y - bias if !(y != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ERANGE) } @@ -26777,10 +26777,10 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { trc("tls=%v f=%v prec=%v pok=%v, (%v:)", tls, f, prec, pok, origin(2)) defer func() { trc("-> %v", r) }() } - var bits, c, emin, sign, v1, v12, v19, v2, v22, v27, v34, v5, v6, v8 int32 - var i, v31 Tsize_t - var v10, v13, v14, v20, v21, v23, v24, v28, v29, v3, v35, v36, v4, v9 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v10, v12, v13, v14, v19, v2, v20, v21, v22, v23, v24, v27, v28, v29, v3, v31, v34, v35, v36, v4, v5, v6, v8, v9 + var bits, c, emin, sign, v1, v2, v5, v6 int32 + var i, v27 Tsize_t + var v3, v4 uintptr + _, _, _, _, _, _, _, _, _, _, _, _ = bits, c, emin, i, sign, v1, v2, v27, v3, v4, v5, v6 sign = int32(1) switch prec { case 0: @@ -26799,7 +26799,7 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -26815,16 +26815,16 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } } if c == int32('+') || c == int32('-') { - sign -= int32(2) * BoolInt32(c == int32('-')) + sign = sign - int32(2)*BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } i = uint64(0) for { @@ -26833,24 +26833,24 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(7) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v14 = f + 8 - v13 = *(*uintptr)(unsafe.Pointer(v14)) - *(*uintptr)(unsafe.Pointer(v14))++ - v12 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v13))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v12 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v12 + c = v1 } goto _11 _11: ; - i++ + i = i + 1 } if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 { if i != uint64(8) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { for { @@ -26858,12 +26858,12 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - goto _16 - _16: + goto _15 + _15: ; - i-- + i = i - 1 } } } @@ -26877,55 +26877,55 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if i < uint64(2) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v21 = f + 8 - v20 = *(*uintptr)(unsafe.Pointer(v21)) - *(*uintptr)(unsafe.Pointer(v21))++ - v19 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v20))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v19 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v19 + c = v1 } - goto _18 - _18: + goto _16 + _16: ; - i++ + i = i + 1 } } if i == uint64(3) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v24 = f + 8 - v23 = *(*uintptr)(unsafe.Pointer(v24)) - *(*uintptr)(unsafe.Pointer(v24))++ - v22 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v22 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v22 != int32('(') { + if v1 != int32('(') { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } i = uint64(1) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v29 = f + 8 - v28 = *(*uintptr)(unsafe.Pointer(v29)) - *(*uintptr)(unsafe.Pointer(v29))++ - v27 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v27 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v27 + c = v1 if Uint32FromInt32(c-int32('0')) < uint32(10) || Uint32FromInt32(c-int32('A')) < uint32(26) || Uint32FromInt32(c-int32('a')) < uint32(26) || c == int32('_') { - goto _26 + goto _23 } if c == int32(')') { return float64(X__builtin_nanf(tls, __ccgo_ts)) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !(pok != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -26933,26 +26933,26 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { return Float64FromInt32(0) } for { - v31 = i - i-- - if !(v31 != 0) { + v27 = i + i = i - 1 + if !(v27 != 0) { break } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } return float64(X__builtin_nanf(tls, __ccgo_ts)) - goto _26 - _26: + goto _23 + _23: ; - i++ + i = i + 1 } return float64(X__builtin_nanf(tls, __ccgo_ts)) } if i != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -26960,19 +26960,19 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) (r float64) { } if c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v36 = f + 8 - v35 = *(*uintptr)(unsafe.Pointer(v36)) - *(*uintptr)(unsafe.Pointer(v36))++ - v34 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v35))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v34 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v34 + c = v1 if c|int32(32) == int32('x') { return _hexfloat(tls, f, bits, emin, sign, pok) } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } c = int32('0') } @@ -27246,11 +27246,11 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint trc("tls=%v f=%v base=%v pok=%v lim=%v, (%v:)", tls, f, base, pok, lim, origin(2)) defer func() { trc("-> %v", r) }() } - var bs, c, neg, v1, v11, v14, v2, v21, v25, v29, v33, v37, v41, v45, v5, v6, v8 int32 - var val, v10, v12, v13, v15, v16, v22, v23, v26, v27, v3, v30, v31, v34, v35, v38, v39, v4, v42, v43, v46, v47, v9 uintptr + var bs, c, neg, v1, v2, v5, v6 int32 + var val, v3, v4 uintptr var x uint32 var y uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v10, v11, v12, v13, v14, v15, v16, v2, v21, v22, v23, v25, v26, v27, v29, v3, v30, v31, v33, v34, v35, v37, v38, v39, v4, v41, v42, v43, v45, v46, v47, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = bs, c, neg, val, x, y, v1, v2, v3, v4, v5, v6 val = uintptr(unsafe.Pointer(&_table6)) + uintptr(1) neg = 0 if base > uint32(36) || base == uint32(1) { @@ -27261,7 +27261,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__shgetc(tls, f) @@ -27279,42 +27279,42 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint if c == int32('+') || c == int32('-') { neg = -BoolInt32(c == int32('-')) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v10 = f + 8 - v9 = *(*uintptr)(unsafe.Pointer(v10)) - *(*uintptr)(unsafe.Pointer(v10))++ - v8 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v8 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v8 + c = v1 } if (base == uint32(0) || base == uint32(16)) && c == int32('0') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v11 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v11 + c = v1 if c|int32(32) == int32('x') { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v15))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v14 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v14 + c = v1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= int32(16) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if pok != 0 { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } } else { X__shlim(tls, f, int64(Int32FromInt32(0))) @@ -27333,7 +27333,7 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint } if uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -27347,18 +27347,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x*uint32(10) + Uint32FromInt32(c-Int32FromUint8('0')) - goto _20 - _20: + goto _17 + _17: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v23 = f + 8 - v22 = *(*uintptr)(unsafe.Pointer(v23)) - *(*uintptr)(unsafe.Pointer(v23))++ - v21 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v22))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v21 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v21 + c = v1 } y = uint64(x) for { @@ -27366,18 +27366,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } y = y*uint64(10) + Uint64FromInt32(c-Int32FromUint8('0')) - goto _24 - _24: + goto _21 + _21: ; if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v27 = f + 8 - v26 = *(*uintptr)(unsafe.Pointer(v27)) - *(*uintptr)(unsafe.Pointer(v27))++ - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v26))) + v4 = f + 8 + v3 = *(*uintptr)(unsafe.Pointer(v4)) + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { - v25 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v25 + c = v1 } if Uint32FromInt32(c-int32('0')) >= uint32(10) { goto done @@ -27391,18 +27391,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) (r uint break } x = x<= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if y >= lim { if !(lim&Uint64FromInt32(1) != 0) && !(neg != 0) { @@ -27525,7 +27525,7 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _1 _1: ; - i++ + i = i + 1 } if !(fd != 0) { *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8('0') @@ -27540,21 +27540,21 @@ func X__procfdname(tls *TLS, buf uintptr, fd uint32) { goto _3 _3: ; - j /= uint32(10) - i++ + j = j / uint32(10) + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = uint8(0) for { if !(fd != 0) { break } - i-- + i = i - 1 v5 = i *(*uint8)(unsafe.Pointer(buf + uintptr(v5))) = uint8(uint32('0') + fd%uint32(10)) goto _4 _4: ; - fd /= uint32(10) + fd = fd / uint32(10) } } @@ -27597,7 +27597,7 @@ func X__shgetc(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Fshlim = int64(-int32(1)) return -int32(1) } - cnt++ + cnt = cnt + 1 if (*TFILE)(unsafe.Pointer(f)).Fshlim != 0 && int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos) > (*TFILE)(unsafe.Pointer(f)).Fshlim-cnt { (*TFILE)(unsafe.Pointer(f)).Fshend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr((*TFILE)(unsafe.Pointer(f)).Fshlim-cnt) } else { @@ -28341,7 +28341,7 @@ func Xgetloadavg(tls *TLS, a uintptr, n int32) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return n } @@ -28548,7 +28548,7 @@ func Xgetpass(tls *TLS, prompt uintptr) (r uintptr) { l = Xread(tls, fd, uintptr(unsafe.Pointer(&_password)), uint64(128)) if l >= 0 { if l > 0 && Int32FromUint8(_password[l-int64(1)]) == int32('\n') || Uint64FromInt64(l) == uint64(128) { - l-- + l = l - 1 } _password[l] = uint8(0) } @@ -29041,7 +29041,7 @@ func Xadjtime(tls *TLS, in uintptr, out uintptr) (r int32) { v1 = (*(*Ttimex)(unsafe.Pointer(bp))).Foffset % Int64FromInt32(1000000) (*Ttimeval)(unsafe.Pointer(out)).Ftv_usec = v1 if v1 < 0 { - (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec-- + (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec = (*Ttimeval)(unsafe.Pointer(out)).Ftv_sec - 1 *(*Tsuseconds_t)(unsafe.Pointer(out + 8)) += int64(1000000) } } @@ -30217,7 +30217,7 @@ func Xprctl(tls *TLS, op int32, va uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } _ = ap return int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall5(tls, int64(SYS_prctl), int64(op), Int64FromUint64(x[0]), Int64FromUint64(x[int32(1)]), Int64FromUint64(x[int32(2)]), Int64FromUint64(x[int32(3)]))))) @@ -31166,8 +31166,8 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { if uint64(n) >= size/uint64(4) || uint64(o) >= size-uint64(uint32(4)*n) || uint64(t) >= size-uint64(uint32(4)*n) || (o|t)%uint32(4) != 0 { return uintptr(0) } - o /= uint32(4) - t /= uint32(4) + o = o / uint32(4) + t = t / uint32(4) for { ol = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2)))*4)), sw) os = _swapc(tls, *(*Tuint32_t)(unsafe.Pointer(mo + uintptr(o+uint32(2)*(b+n/uint32(2))+uint32(1))*4)), sw) @@ -31187,10 +31187,10 @@ func X__mo_lookup(tls *TLS, p uintptr, size Tsize_t, s uintptr) (r uintptr) { return uintptr(0) } else { if sign < 0 { - n /= uint32(2) + n = n / uint32(2) } else { - b += n / uint32(2) - n -= n / uint32(2) + b = b + n/uint32(2) + n = n - n/uint32(2) } } } @@ -31283,7 +31283,7 @@ func Xcatgets(tls *TLS, catd Tnl_catd, set_id int32, msg_id int32, s uintptr) (r return s } nmsgs = *(*Tuint32_t)(unsafe.Pointer(set + UintptrFromInt32(4))) - msgs += uintptr(uint32(12) * *(*Tuint32_t)(unsafe.Pointer(set + UintptrFromInt32(8)))) + msgs = msgs + uintptr(uint32(12)**(*Tuint32_t)(unsafe.Pointer(set + UintptrFromInt32(8)))) msg = Xbsearch(tls, bp+4, msgs, uint64(nmsgs), uint64(12), __ccgo_fp(_cmp)) if !(msg != 0) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ENOMSG) @@ -31378,10 +31378,10 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { defer tls.Free(4096) var catd Tnl_catd var i, l Tsize_t - var lang, p, path, v, z, v1, v3, v6, v7 uintptr + var lang, p, path, v, z, v1 uintptr var v2 bool var _ /* buf at bp+0 */ [4096]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _ = catd, i, l, lang, p, path, v, z, v1, v2, v3, v6, v7 + _, _, _, _, _, _, _, _, _, _ = catd, i, l, lang, p, path, v, z, v1, v2 if Xstrchr(tls, name, int32('/')) != 0 { return _do_catopen(tls, name) } @@ -31394,11 +31394,11 @@ func Xcatopen(tls *TLS, name uintptr, oflag int32) (r Tnl_catd) { return uintptr(-Int32FromInt32(1)) } if oflag != 0 { - v3 = Xnl_langinfo(tls, Int32FromInt32(LC_MESSAGES)<= rem { goto notrans } - trans += uintptr(l + uint64(1)) + trans = trans + uintptr(l+uint64(1)) } } *(*int32)(unsafe.Pointer(X__errno_location(tls))) = old_errno @@ -98095,7 +98095,7 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { break } for *(*uint8)(unsafe.Pointer(a)) != 0 && uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32)-uint32('a') > uint32(26) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a)))-int32('0')) > uint32(10) { - a++ + a = a + 1 } if uint32(*(*uint8)(unsafe.Pointer(a)))|uint32(32) != uint32(*(*uint8)(unsafe.Pointer(b))) { return int32(1) @@ -98103,8 +98103,8 @@ func _fuzzycmp(tls *TLS, a uintptr, b uintptr) (r int32) { goto _1 _1: ; - a++ - b++ + a = a + 1 + b = b + 1 } return BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(a))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(b)))) } @@ -98128,16 +98128,16 @@ func _find_charmap(tls *TLS, name uintptr) (r Tsize_t) { goto _2 _2: ; - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } return Uint64FromInt64(int64(s+uintptr(1)) - t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_charmaps)))) } - s += uintptr(Xstrlen(tls, s) + uint64(1)) + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) > int32(0200) { - s += uintptr(2) + s = s + uintptr(2) } else { - s += uintptr(uint32(2) + (uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) + s = s + uintptr(uint32(2)+(uint32(64)-uint32(*(*uint8)(unsafe.Pointer(s + 1))))*uint32(5)) } } goto _1 @@ -98204,23 +98204,23 @@ func Xiconv_open(tls *TLS, to uintptr, from uintptr) (r Ticonv_t) { } func _get_16(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(1) + e = e & int32(1) return Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(e))))<> int32(8)) *(*uint8)(unsafe.Pointer(s + uintptr(int32(1)-e))) = uint8(c) } func _get_32(tls *TLS, s uintptr, e int32) (r uint32) { - e &= int32(3) + e = e & int32(3) return (uint32(*(*uint8)(unsafe.Pointer(s + uintptr(e))))+0)<> int32(24)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(1)))) = uint8(c >> int32(16)) *(*uint8)(unsafe.Pointer(s + uintptr(e^int32(2)))) = uint8(c >> int32(8)) @@ -98261,10 +98261,10 @@ func _uni_to_jis(tls *TLS, c uint32) (r uint32) { return uint32(0) } else { if c < d { - nel /= uint32(2) + nel = nel / uint32(2) } else { - b += i - nel -= nel / uint32(2) + b = b + i + nel = nel - nel/uint32(2) } } } @@ -98282,10 +98282,10 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui bp := tls.Alloc(64) defer tls.Free(64) var c, d, from, to, v62 uint32 - var err, i, i1, j, j1, v25, v26, v27, v28, v59 int32 + var err, i, i1, j, j1, v25, v26, v27 int32 var k, l, tmplen, tmpx, x Tsize_t var loc Tlocale_t - var map1, ploc, scd, tomap, v100, v101, v102, v103, v104, v54, v55, v57, v58, v60, v61, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 uintptr + var map1, ploc, scd, tomap, v54, v55 uintptr var totype, type1 uint8 var _ /* ptmp at bp+48 */ uintptr var _ /* st at bp+24 */ Tmbstate_t @@ -98295,7 +98295,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } var _ /* tmp at bp+56 */ [4]uint8 var _ /* wc at bp+32 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v100, v101, v102, v103, v104, v25, v26, v27, v28, v54, v55, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, d, err, from, i, i1, j, j1, k, l, loc, map1, ploc, scd, tmplen, tmpx, to, tomap, totype, type1, x, v25, v26, v27, v54, v55, v62 x = uint64(0) scd = uintptr(0) if !(uint64(cd)&Uint64FromInt32(1) != 0) { @@ -98483,11 +98483,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } c = _get_32(tls, *(*uintptr)(unsafe.Pointer(in)), 0) if c == uint32(0xfffe0000) { - v28 = int32(UTF_32LE) + v25 = int32(UTF_32LE) } else { - v28 = int32(UTF_32BE) + v25 = int32(UTF_32BE) } - (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v28) + (*Tstateful_cd)(unsafe.Pointer(scd)).Fstate = Uint32FromInt32(v25) if c == uint32(0xfffe0000) || c == uint32(0xfeff) { l = uint64(4) } @@ -98500,7 +98500,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _23 } if c-uint32(0xa1) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } l = uint64(2) @@ -98509,27 +98509,27 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) if c-uint32(129) <= Uint32FromInt32(Int32FromInt32(159)-Int32FromInt32(129)) { - c -= uint32(129) + c = c - uint32(129) } else { if c-uint32(224) <= Uint32FromInt32(Int32FromInt32(239)-Int32FromInt32(224)) { - c -= uint32(193) + c = c - uint32(193) } else { goto ilseq } } - c *= uint32(2) + c = c * uint32(2) if d-uint32(64) <= Uint32FromInt32(Int32FromInt32(158)-Int32FromInt32(64)) { if d == uint32(127) { goto ilseq } if d > uint32(127) { - d-- + d = d - 1 } - d -= uint32(64) + d = d - uint32(64) } else { if d-uint32(159) <= Uint32FromInt32(Int32FromInt32(252)-Int32FromInt32(159)) { - c++ - d -= uint32(159) + c = c + 1 + d = d - uint32(159) } } if c >= uint32(84) { @@ -98555,11 +98555,11 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c-uint32(0xa1) > Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { goto ilseq } - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0xa1)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0xa1)) goto _23 } - c -= uint32(0xa1) - d -= uint32(0xa1) + c = c - uint32(0xa1) + d = d - uint32(0xa1) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98618,8 +98618,8 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto starved } d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(1)))) - c -= uint32(0x21) - d -= uint32(0x21) + c = c - uint32(0x21) + d = d - uint32(0x21) if c >= uint32(84) || d >= uint32(94) { goto ilseq } @@ -98632,7 +98632,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto ilseq } if c-uint32(0x21) < uint32(0x5e) { - c += Uint32FromInt32(Int32FromInt32(0xff61) - Int32FromInt32(0x21)) + c = c + Uint32FromInt32(Int32FromInt32(0xff61)-Int32FromInt32(0x21)) } break } @@ -98656,7 +98656,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if c < uint32(128) { goto _23 } - c -= uint32(0x81) + c = c - uint32(0x81) if c >= uint32(126) { goto ilseq } @@ -98681,13 +98681,13 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x81) > uint32(126) { goto ilseq } - c += uint32(10) * (d - uint32(0x81)) + c = c + uint32(10)*(d-uint32(0x81)) d = uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(in)) + UintptrFromInt32(3)))) if d-uint32('0') > uint32(9) { goto ilseq } - c += d - uint32('0') - c += uint32(128) + c = c + (d - uint32('0')) + c = c + uint32(128) d = uint32(0) for { if !(d <= c) { @@ -98705,17 +98705,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(i)*380 + uintptr(j)*2)))-d <= c-d { - k++ + k = k + 1 } goto _31 _31: ; - j++ + j = j + 1 } goto _30 _30: ; - i++ + i = i + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98724,9 +98724,9 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } goto _23 } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(63) { - d-- + d = d - 1 } c = uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_gb18030)) + uintptr(c)*380 + uintptr(d)*2))) goto _23 @@ -98743,18 +98743,18 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if d-uint32(0x40) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x40)) || d-uint32(0x7f) < Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x7f)) { goto ilseq } - d -= uint32(0x40) + d = d - uint32(0x40) if d > uint32(0x3e) { - d -= uint32(0x22) + d = d - uint32(0x22) } if c-uint32(0xa1) >= Uint32FromInt32(Int32FromInt32(0xfa)-Int32FromInt32(0xa1)) { if c-uint32(0x87) >= Uint32FromInt32(Int32FromInt32(0xff)-Int32FromInt32(0x87)) { goto ilseq } if c < uint32(0xa1) { - c -= uint32(0x87) + c = c - uint32(0x87) } else { - c -= Uint32FromInt32(Int32FromInt32(0x87) + (Int32FromInt32(0xfa) - Int32FromInt32(0xa1))) + c = c - Uint32FromInt32(Int32FromInt32(0x87)+(Int32FromInt32(0xfa)-Int32FromInt32(0xa1))) } c = Uint32FromInt32(Int32FromUint16(_hkscs[uint32(4867)+(c*uint32(157)+d)/uint32(16)])>>((c*uint32(157)+d)%uint32(16))%int32(2)<= uint32(93) || d >= uint32(94) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0x81)) - d += uint32(0xa1) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0x81)) + d = d + uint32(0xa1) if c >= uint32(93) || c >= Uint32FromInt32(Int32FromInt32(0xc6)-Int32FromInt32(0x81)) && d > uint32(0x52) { goto ilseq } @@ -98826,7 +98826,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } else { c = Uint32FromInt32(Int32FromInt32(178)*Int32FromInt32(0x20)) + uint32(84)*(c-uint32(0x20)) + d } - c += uint32(0xac00) + c = c + uint32(0xac00) d = uint32(0xac00) for { if !(d <= c) { @@ -98844,17 +98844,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui break } if uint32(*(*uint16)(unsafe.Pointer(uintptr(unsafe.Pointer(&_ksc)) + uintptr(i1)*188 + uintptr(j1)*2)))-d <= c-d { - k++ + k = k + 1 } goto _34 _34: ; - j1++ + j1 = j1 + 1 } goto _33 _33: ; - i1++ + i1 = i1 + 1 } d = c + uint32(1) c = uint32(uint64(c) + k) @@ -98945,7 +98945,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto subst subst: ; - x++ + x = x + 1 c = Uint32FromUint8('*') _52: ; @@ -98965,7 +98965,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } v55 = out v54 = *(*uintptr)(unsafe.Pointer(v55)) - *(*uintptr)(unsafe.Pointer(v55))++ + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 *(*uint8)(unsafe.Pointer(v54)) = uint8(c) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(1) goto _51 @@ -98983,7 +98983,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto _56 _56: ; - c++ + c = c + 1 } goto subst _39: @@ -98992,17 +98992,17 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c == uint32(0xa5) { - x++ + x = x + 1 c = uint32('\\') goto revout } if c == uint32(0x203e) { - x++ + x = x + 1 c = uint32('~') goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0xa1) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0xa1)-Int32FromInt32(0xff61)) goto revout } c = _uni_to_jis(tls, c) @@ -99014,24 +99014,24 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui } d = c % uint32(256) c = c / uint32(256) - v58 = out - v57 = *(*uintptr)(unsafe.Pointer(v58)) - *(*uintptr)(unsafe.Pointer(v58))++ + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c < uint32(95) { - v59 = int32(112) + v25 = int32(112) } else { - v59 = int32(176) + v25 = int32(176) } - *(*uint8)(unsafe.Pointer(v57)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v59)) - v61 = out - v60 = *(*uintptr)(unsafe.Pointer(v61)) - *(*uintptr)(unsafe.Pointer(v61))++ + *(*uint8)(unsafe.Pointer(v54)) = uint8((c+uint32(1))/uint32(2) + Uint32FromInt32(v25)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 if c%uint32(2) != 0 { v62 = d + uint32(31) + d/uint32(96) } else { v62 = d + uint32(126) } - *(*uint8)(unsafe.Pointer(v60)) = uint8(v62) + *(*uint8)(unsafe.Pointer(v54)) = uint8(v62) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _40: @@ -99040,7 +99040,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui goto revout } if c-uint32(0xff61) <= Uint32FromInt32(Int32FromInt32(0xdf)-Int32FromInt32(0xa1)) { - c += Uint32FromInt32(Int32FromInt32(0x0e00) + Int32FromInt32(0x21) - Int32FromInt32(0xff61)) + c = c + Uint32FromInt32(Int32FromInt32(0x0e00)+Int32FromInt32(0x21)-Int32FromInt32(0xff61)) } else { c = _uni_to_jis(tls, c) } @@ -99050,14 +99050,14 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(2) { goto toobig } - v64 = out - v63 = *(*uintptr)(unsafe.Pointer(v64)) - *(*uintptr)(unsafe.Pointer(v64))++ - *(*uint8)(unsafe.Pointer(v63)) = uint8(c/uint32(256) + uint32(0x80)) - v66 = out - v65 = *(*uintptr)(unsafe.Pointer(v66)) - *(*uintptr)(unsafe.Pointer(v66))++ - *(*uint8)(unsafe.Pointer(v65)) = uint8(c%uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c/uint32(256) + uint32(0x80)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c%uint32(256) + uint32(0x80)) *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(2) goto _51 _41: @@ -99069,56 +99069,56 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(7) { goto toobig } - v68 = out - v67 = *(*uintptr)(unsafe.Pointer(v68)) - *(*uintptr)(unsafe.Pointer(v68))++ - *(*uint8)(unsafe.Pointer(v67)) = uint8('\033') - v70 = out - v69 = *(*uintptr)(unsafe.Pointer(v70)) - *(*uintptr)(unsafe.Pointer(v70))++ - *(*uint8)(unsafe.Pointer(v69)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') if c == uint32(0xa5) { - v72 = out - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - *(*uint8)(unsafe.Pointer(v71)) = uint8('J') - v74 = out - v73 = *(*uintptr)(unsafe.Pointer(v74)) - *(*uintptr)(unsafe.Pointer(v74))++ - *(*uint8)(unsafe.Pointer(v73)) = uint8('\\') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\\') } else { if c == uint32(0x203e) { - v76 = out - v75 = *(*uintptr)(unsafe.Pointer(v76)) - *(*uintptr)(unsafe.Pointer(v76))++ - *(*uint8)(unsafe.Pointer(v75)) = uint8('J') - v78 = out - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - *(*uint8)(unsafe.Pointer(v77)) = uint8('~') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('J') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('~') } else { - v80 = out - v79 = *(*uintptr)(unsafe.Pointer(v80)) - *(*uintptr)(unsafe.Pointer(v80))++ - *(*uint8)(unsafe.Pointer(v79)) = uint8('I') - v82 = out - v81 = *(*uintptr)(unsafe.Pointer(v82)) - *(*uintptr)(unsafe.Pointer(v82))++ - *(*uint8)(unsafe.Pointer(v81)) = uint8(c - uint32(0xff61) + uint32(0x21)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('I') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c - uint32(0xff61) + uint32(0x21)) } } - v84 = out - v83 = *(*uintptr)(unsafe.Pointer(v84)) - *(*uintptr)(unsafe.Pointer(v84))++ - *(*uint8)(unsafe.Pointer(v83)) = uint8('\033') - v86 = out - v85 = *(*uintptr)(unsafe.Pointer(v86)) - *(*uintptr)(unsafe.Pointer(v86))++ - *(*uint8)(unsafe.Pointer(v85)) = uint8('(') - v88 = out - v87 = *(*uintptr)(unsafe.Pointer(v88)) - *(*uintptr)(unsafe.Pointer(v88))++ - *(*uint8)(unsafe.Pointer(v87)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(7) goto _51 } @@ -99129,38 +99129,38 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(8) { goto toobig } - v90 = out - v89 = *(*uintptr)(unsafe.Pointer(v90)) - *(*uintptr)(unsafe.Pointer(v90))++ - *(*uint8)(unsafe.Pointer(v89)) = uint8('\033') - v92 = out - v91 = *(*uintptr)(unsafe.Pointer(v92)) - *(*uintptr)(unsafe.Pointer(v92))++ - *(*uint8)(unsafe.Pointer(v91)) = uint8('$') - v94 = out - v93 = *(*uintptr)(unsafe.Pointer(v94)) - *(*uintptr)(unsafe.Pointer(v94))++ - *(*uint8)(unsafe.Pointer(v93)) = uint8('B') - v96 = out - v95 = *(*uintptr)(unsafe.Pointer(v96)) - *(*uintptr)(unsafe.Pointer(v96))++ - *(*uint8)(unsafe.Pointer(v95)) = uint8(c / uint32(256)) - v98 = out - v97 = *(*uintptr)(unsafe.Pointer(v98)) - *(*uintptr)(unsafe.Pointer(v98))++ - *(*uint8)(unsafe.Pointer(v97)) = uint8(c % uint32(256)) - v100 = out - v99 = *(*uintptr)(unsafe.Pointer(v100)) - *(*uintptr)(unsafe.Pointer(v100))++ - *(*uint8)(unsafe.Pointer(v99)) = uint8('\033') - v102 = out - v101 = *(*uintptr)(unsafe.Pointer(v102)) - *(*uintptr)(unsafe.Pointer(v102))++ - *(*uint8)(unsafe.Pointer(v101)) = uint8('(') - v104 = out - v103 = *(*uintptr)(unsafe.Pointer(v104)) - *(*uintptr)(unsafe.Pointer(v104))++ - *(*uint8)(unsafe.Pointer(v103)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('$') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c / uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8(c % uint32(256)) + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('\033') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('(') + v55 = out + v54 = *(*uintptr)(unsafe.Pointer(v55)) + *(*uintptr)(unsafe.Pointer(v55)) = *(*uintptr)(unsafe.Pointer(v55)) + 1 + *(*uint8)(unsafe.Pointer(v54)) = uint8('B') *(*Tsize_t)(unsafe.Pointer(outb)) -= uint64(8) goto _51 _42: @@ -99191,7 +99191,7 @@ func Xiconv(tls *TLS, cd Ticonv_t, in uintptr, inb uintptr, out uintptr, outb ui if *(*Tsize_t)(unsafe.Pointer(outb)) < uint64(4) { goto toobig } - c -= uint32(0x10000) + c = c - uint32(0x10000) _put_16(tls, *(*uintptr)(unsafe.Pointer(out)), c>>int32(10)|uint32(0xd800), Int32FromUint8(totype)) _put_16(tls, *(*uintptr)(unsafe.Pointer(out))+UintptrFromInt32(2), c&uint32(0x3ff)|uint32(0xdc00), Int32FromUint8(totype)) *(*uintptr)(unsafe.Pointer(out)) += uintptr(4) @@ -99268,8 +99268,8 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var cat, idx int32 - var str, v1, v2 uintptr - _, _, _, _, _ = cat, idx, str, v1, v2 + var str, v1 uintptr + _, _, _, _ = cat, idx, str, v1 cat = item >> int32(16) idx = item & int32(65535) if item == int32(CODESET) { @@ -99283,11 +99283,11 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { /* _NL_LOCALE_NAME extension */ if idx == int32(65535) && cat < int32(LC_ALL) { if *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) != 0 { - v2 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 + v1 = *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8)) + 16 } else { - v2 = __ccgo_ts + 562 + v1 = __ccgo_ts + 562 } - return v2 + return v1 } switch cat { case int32(LC_NUMERIC): @@ -99324,13 +99324,13 @@ func X__nl_langinfo_l(tls *TLS, item Tnl_item, loc Tlocale_t) (r uintptr) { goto _4 _4: ; - str++ + str = str + 1 } goto _3 _3: ; - idx-- - str++ + idx = idx - 1 + str = str + 1 } if cat != int32(LC_NUMERIC) && *(*uint8)(unsafe.Pointer(str)) != 0 { str = X__lctrans(tls, str, *(*uintptr)(unsafe.Pointer(loc + uintptr(cat)*8))) @@ -99399,11 +99399,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { defer tls.Free(272) var builtin int32 var l, n Tsize_t - var map1, new1, p, path, z, v1, v11, v2, v4, v6 uintptr - var v12, v3, v5, v7 bool + var map1, new1, p, path, z, v1, v2, v4, v6 uintptr + var v3, v5, v7 bool var _ /* buf at bp+0 */ [256]uint8 var _ /* map_size at bp+256 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v11, v12, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = builtin, l, map1, n, new1, p, path, z, v1, v2, v3, v4, v5, v6, v7 new1 = uintptr(0) path = uintptr(0) if !(*(*uint8)(unsafe.Pointer(val)) != 0) { @@ -99432,7 +99432,7 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { goto _8 _8: ; - n++ + n = n + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) == int32('.') || *(*uint8)(unsafe.Pointer(val + uintptr(n))) != 0 { val = __ccgo_ts + 571 @@ -99500,11 +99500,11 @@ func X__get_locale(tls *TLS, cat int32, val uintptr) (r uintptr) { * object anyway to store the name, which is kept for the * sake of being able to do message translations at the * application level. */ - if v12 = !(new1 != 0); v12 { - v11 = Xmalloc(tls, uint64(48)) - new1 = v11 + if v3 = !(new1 != 0); v3 { + v1 = Xmalloc(tls, uint64(48)) + new1 = v1 } - if v12 && v11 != 0 { + if v3 && v1 != 0 { (*t__locale_map)(unsafe.Pointer(new1)).Fmap1 = X__c_dot_utf8.Fmap1 (*t__locale_map)(unsafe.Pointer(new1)).Fmap_size = X__c_dot_utf8.Fmap_size Xmemcpy(tls, new1+16, val, n) @@ -99608,7 +99608,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _1 _1: ; - i++ + i = i + 1 } /* For locales with allocated storage, modify in-place. */ if X__loc_is_allocated(tls, loc) != 0 { @@ -99636,7 +99636,7 @@ func _do_newlocale(tls *TLS, mask int32, name uintptr, loc Tlocale_t) (r Tlocale goto _4 _4: ; - i1++ + i1 = i1 + 1 } *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_ctype_locale)))) = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&_default_locale)))) _default_locale_init_done = int32(1) @@ -99713,7 +99713,7 @@ func _skipspace(tls *TLS, s uintptr) (r uintptr) { if !(v2 != 0) { break } - s++ + s = s + 1 } return s } @@ -99724,7 +99724,7 @@ func _evalprim(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var v1 int32 var _ /* e at bp+0 */ uintptr _ = v1 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99834,7 +99834,7 @@ func _parseop(tls *TLS, st uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } (*Tst)(unsafe.Pointer(st)).Fop = int32(13) return s @@ -99848,7 +99848,7 @@ func _evalbinop(tls *TLS, st uintptr, s uintptr, minprec int32, d int32) (r uint var left uint64 var op int32 _, _ = left, op - d-- + d = d - 1 s = _evalprim(tls, st, s, d) s = _parseop(tls, st, s) for { @@ -99892,7 +99892,7 @@ func _evalexpr(tls *TLS, st uintptr, s uintptr, d int32) (r uintptr) { var a, b, v2 uint64 var v1 int32 _, _, _, _ = a, b, v1, v2 - d-- + d = d - 1 v1 = d if v1 < 0 { return __ccgo_ts @@ -99948,10 +99948,10 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { defer tls.Free(80) var i, same int32 var l Tsize_t - var lm, lm1, p, part1, ret, s, z, v3, v4, v5, v6 uintptr + var lm, lm1, p, part1, ret, s, z, v3 uintptr var _ /* part at bp+48 */ [24]uint8 var _ /* tmp_locale at bp+0 */ t__locale_struct - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3, v4, v5, v6 + _, _, _, _, _, _, _, _, _, _, _ = i, l, lm, lm1, p, part1, ret, s, same, z, v3 if Uint32FromInt32(cat) > uint32(LC_ALL) { return uintptr(0) } @@ -99987,7 +99987,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } X__libc.Fglobal_locale = *(*t__locale_struct)(unsafe.Pointer(bp)) } @@ -100000,7 +100000,7 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { } lm1 = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(i)*8)) if lm1 == *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56)) { - same++ + same = same + 1 } if lm1 != 0 { v3 = lm1 + 16 @@ -100011,22 +100011,22 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { l = Xstrlen(tls, part1) Xmemcpy(tls, s, part1, l) *(*uint8)(unsafe.Pointer(s + uintptr(l))) = uint8(';') - s += uintptr(l + uint64(1)) + s = s + uintptr(l+uint64(1)) goto _2 _2: ; - i++ + i = i + 1 } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + s = s - 1 + v3 = s + *(*uint8)(unsafe.Pointer(v3)) = uint8(0) ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) if same == int32(LC_ALL) { - v5 = part1 + v3 = part1 } else { - v5 = uintptr(unsafe.Pointer(&_buf1)) + v3 = uintptr(unsafe.Pointer(&_buf1)) } - return v5 + return v3 } if name != 0 { lm = X__get_locale(tls, cat, name) @@ -100039,11 +100039,11 @@ func Xsetlocale(tls *TLS, cat int32, name uintptr) (r uintptr) { lm = *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__libc)) + 56 + uintptr(cat)*8)) } if lm != 0 { - v6 = lm + 16 + v3 = lm + 16 } else { - v6 = __ccgo_ts + 562 + v3 = __ccgo_ts + 562 } - ret = v6 + ret = v3 ___unlock(tls, uintptr(unsafe.Pointer(&X__locale_lock))) return ret } @@ -100077,9 +100077,9 @@ func _vstrfmon_l(tls *TLS, s uintptr, n Tsize_t, loc Tlocale_t, fmt uintptr, ap defer tls.Free(32) var fill, fw, intl, left, lp, negpar, nogrp, nosym, rp, w int32 var l Tsize_t - var s0, v12, v5, v6, v8 uintptr + var s0, v5, v6 uintptr var x float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v12, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = fill, fw, intl, l, left, lp, negpar, nogrp, nosym, rp, s0, w, x, v5, v6 s0 = s _3: ; @@ -100093,15 +100093,15 @@ _3: literal: ; v5 = s - s++ + s = s + 1 v6 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - n-- + n = n - 1 goto _2 _4: ; - fmt++ + fmt = fmt + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('%') { goto literal } @@ -100113,9 +100113,9 @@ _4: for { switch Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) { case int32('='): - fmt++ - v8 = fmt - fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v8))) + fmt = fmt + 1 + v5 = fmt + fill = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) goto _7 case int32('^'): nogrp = int32(1) @@ -100136,7 +100136,7 @@ _4: goto _7 _7: ; - fmt++ + fmt = fmt + 1 } fw = 0 for { @@ -100147,13 +100147,13 @@ _4: goto _9 _9: ; - fmt++ + fmt = fmt + 1 } lp = 0 rp = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('#') { lp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100162,12 +100162,12 @@ _4: goto _10 _10: ; - fmt++ + fmt = fmt + 1 } } if Int32FromUint8(*(*uint8)(unsafe.Pointer(fmt))) == int32('.') { rp = 0 - fmt++ + fmt = fmt + 1 for { if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(fmt)))-uint32('0') < uint32(10)) != 0) { break @@ -100176,12 +100176,12 @@ _4: goto _11 _11: ; - fmt++ + fmt = fmt + 1 } } - v12 = fmt - fmt++ - intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v12))) == int32('i')) + v5 = fmt + fmt = fmt + 1 + intl = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) == int32('i')) w = lp + int32(1) + rp if !(left != 0) && fw > w { w = fw @@ -100192,8 +100192,8 @@ _4: *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(E2BIG) return int64(-int32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l goto _2 _2: ; @@ -100388,9 +100388,9 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { trc("tls=%v new1=%v, (%v:)", tls, new1, origin(2)) defer func() { trc("-> %v", r) }() } - var global, old, v1, v2 Tlocale_t + var global, old, v1 Tlocale_t var self Tpthread_t - _, _, _, _, _ = global, old, self, v1, v2 + _, _, _, _ = global, old, self, v1 self = uintptr(___get_tp(tls)) old = (*t__pthread)(unsafe.Pointer(self)).Flocale global = uintptr(unsafe.Pointer(&X__libc)) + 56 @@ -100403,11 +100403,11 @@ func X__uselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { (*t__pthread)(unsafe.Pointer(self)).Flocale = v1 } if old == global { - v2 = uintptr(-Int32FromInt32(1)) + v1 = uintptr(-Int32FromInt32(1)) } else { - v2 = old + v1 = old } - return v2 + return v1 } func Xuselocale(tls *TLS, new1 Tlocale_t) (r Tlocale_t) { @@ -100607,12 +100607,12 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var e, v1, v2 int32 + var e, v1 int32 var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _ = e, v1, v2 + _, _ = e, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -100632,11 +100632,11 @@ func X__fpclassify(tls *TLS, x float64) (r int32) { } if e == int32(0x7ff) { if *(*Tuint64_t)(unsafe.Pointer(bp))< _pio4 { - n++ - fn++ + n = n + 1 + fn = fn + 1 r = x - float64(fn*_pio2_1) w = Tdouble_t(fn * _pio2_1t) } @@ -101017,12 +101017,12 @@ _1: goto _3 _3: ; - i++ + i = i + 1 } (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] = z /* skip zero terms, first term is non-zero */ for (*(*[3]float64)(unsafe.Pointer(bp + 8)))[i] == float64(0) { - i-- + i = i - 1 } n = X__rem_pio2_large(tls, bp+8, bp+32, Int32FromUint32(ix>>Int32FromInt32(20))-(Int32FromInt32(0x3ff)+Int32FromInt32(23)), i+int32(1), int32(1)) if sign != 0 { @@ -101147,10 +101147,10 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec defer tls.Free(240) var carry, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q0 Tint32_t var f, q [20]float64 - var fw, z, v2, v20, v22, v24 float64 + var fw, z, v2 float64 var _ /* fq at bp+80 */ [20]float64 var _ /* iq at bp+0 */ [20]Tint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2, v20, v22, v24 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = carry, f, fw, i, ih, j, jk, jp, jv, jx, jz, k, m, n, q, q0, z, v2 /* initialize jk*/ jk = _init_jk[prec] jp = jk @@ -101178,8 +101178,8 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec goto _1 _1: ; - i++ - j++ + i = i + 1 + j = j + 1 } /* compute q[0],q[1],...q[jk] */ i = 0 @@ -101193,17 +101193,17 @@ func X__rem_pio2_large(tls *TLS, x uintptr, y uintptr, e0 int32, nx int32, prec if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _4 _4: ; - j++ + j = j + 1 } q[i] = fw goto _3 _3: ; - i++ + i = i + 1 } jz = jk goto recompute @@ -101223,18 +101223,18 @@ recompute: goto _5 _5: ; - i++ - j-- + i = i + 1 + j = j - 1 } /* compute n */ - z = Xscalbn(tls, z, q0) /* actual value of z */ - z -= float64(float64(8) * Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ + z = Xscalbn(tls, z, q0) /* actual value of z */ + z = z - float64(float64(8)*Xfloor(tls, float64(z*float64(0.125)))) /* trim off integer >= 8 */ n = int32(z) - z -= float64(n) + z = z - float64(n) ih = 0 if q0 > 0 { /* need iq[jz-1] to determine n */ i = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(24) - q0) - n += i + n = n + i *(*Tint32_t)(unsafe.Pointer(bp + uintptr(jz-int32(1))*4)) -= i << (int32(24) - q0) ih = (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz-int32(1)] >> (int32(23) - q0) } else { @@ -101247,7 +101247,7 @@ recompute: } } if ih > 0 { /* q > 0.5 */ - n += int32(1) + n = n + int32(1) carry = 0 i = 0 for { @@ -101266,7 +101266,7 @@ recompute: goto _6 _6: ; - i++ + i = i + 1 } if q0 > 0 { /* rare case: chance is 1 in 12 */ switch q0 { @@ -101280,7 +101280,7 @@ recompute: if ih == int32(2) { z = float64(1) - z if carry != 0 { - z -= Xscalbn(tls, float64(1), q0) + z = z - Xscalbn(tls, float64(1), q0) } } } @@ -101292,11 +101292,11 @@ recompute: if !(i >= jk) { break } - j |= (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] + j = j | (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i] goto _7 _7: ; - i-- + i = i - 1 } if j == 0 { /* need recomputation */ k = int32(1) @@ -101307,7 +101307,7 @@ recompute: goto _8 _8: ; - k++ + k = k + 1 } /* k = no. of terms needed */ i = jz + int32(1) for { @@ -101321,37 +101321,37 @@ recompute: if !(j <= jx) { break } - fw += float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8)) * f[jx+i-j]) + fw = fw + float64(*(*float64)(unsafe.Pointer(x + uintptr(j)*8))*f[jx+i-j]) goto _10 _10: ; - j++ + j = j + 1 } q[i] = fw goto _9 _9: ; - i++ + i = i + 1 } - jz += k + jz = jz + k goto recompute } } /* chop off zero terms */ if z == float64(0) { - jz -= int32(1) - q0 -= int32(24) + jz = jz - int32(1) + q0 = q0 - int32(24) for (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] == 0 { - jz-- - q0 -= int32(24) + jz = jz - 1 + q0 = q0 - int32(24) } } else { /* break z into 24-bit if necessary */ z = Xscalbn(tls, z, -q0) if z >= float64(1.6777216e+07) { fw = float64(int32(float64(Float64FromFloat64(5.960464477539063e-08) * z))) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z - float64(Float64FromFloat64(1.6777216e+07)*fw)) - jz += int32(1) - q0 += int32(24) + jz = jz + int32(1) + q0 = q0 + int32(24) (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(fw) } else { (*(*[20]Tint32_t)(unsafe.Pointer(bp)))[jz] = int32(z) @@ -101365,11 +101365,11 @@ recompute: break } q[i] = float64(fw * float64((*(*[20]Tint32_t)(unsafe.Pointer(bp)))[i])) - fw *= float64(5.960464477539063e-08) + fw = fw * float64(5.960464477539063e-08) goto _11 _11: ; - i-- + i = i - 1 } /* compute PIo2[0,...,jp]*q[jz,...,0] */ i = jz @@ -101383,17 +101383,17 @@ recompute: if !(k <= jp && k <= jz-i) { break } - fw += float64(_PIo2[k] * q[i+k]) + fw = fw + float64(_PIo2[k]*q[i+k]) goto _13 _13: ; - k++ + k = k + 1 } (*(*[20]float64)(unsafe.Pointer(bp + 80)))[jz-i] = fw goto _12 _12: ; - i-- + i = i - 1 } /* compress fq[] into y[] */ switch prec { @@ -101415,18 +101415,18 @@ _14: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _19 _19: ; - i-- + i = i - 1 } if ih == 0 { - v20 = fw + v2 = fw } else { - v20 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v20 + *(*float64)(unsafe.Pointer(y)) = v2 goto _18 _16: ; @@ -101438,38 +101438,38 @@ _15: if !(i >= 0) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _21 _21: ; - i-- + i = i - 1 } // TODO: drop excess precision here once double_t is used fw = fw if ih == 0 { - v22 = fw + v2 = fw } else { - v22 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y)) = v22 + *(*float64)(unsafe.Pointer(y)) = v2 fw = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] - fw i = int32(1) for { if !(i <= jz) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _23 _23: ; - i++ + i = i + 1 } if ih == 0 { - v24 = fw + v2 = fw } else { - v24 = -fw + v2 = -fw } - *(*float64)(unsafe.Pointer(y + 1*8)) = v24 + *(*float64)(unsafe.Pointer(y + 1*8)) = v2 goto _18 _17: ; /* painful */ @@ -101485,7 +101485,7 @@ _27: goto _26 _26: ; - i-- + i = i - 1 goto _27 goto _25 _25: @@ -101501,7 +101501,7 @@ _25: goto _28 _28: ; - i-- + i = i - 1 } fw = float64(0) i = jz @@ -101509,11 +101509,11 @@ _25: if !(i >= int32(2)) { break } - fw += (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] + fw = fw + (*(*[20]float64)(unsafe.Pointer(bp + 80)))[i] goto _29 _29: ; - i-- + i = i - 1 } if ih == 0 { *(*float64)(unsafe.Pointer(y)) = (*(*[20]float64)(unsafe.Pointer(bp + 80)))[0] @@ -101579,13 +101579,13 @@ func X__rem_pio2f(tls *TLS, x float32, y uintptr) (r int32) { *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) /* Matters with directed rounding. */ if *(*float64)(unsafe.Pointer(y)) < -_pio41 { - n-- - fn-- + n = n - 1 + fn = fn - 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } else { if *(*float64)(unsafe.Pointer(y)) > _pio41 { - n++ - fn++ + n = n + 1 + fn = fn + 1 *(*float64)(unsafe.Pointer(y)) = float64(x) - Tdouble_t(fn*_pio2_11) - Tdouble_t(fn*_pio2_1t1) } } @@ -101742,12 +101742,12 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { trc("tls=%v x=%v y=%v odd=%v, (%v:)", tls, x, y, odd, origin(2)) defer func() { trc("-> %v", r1) }() } - var a, r, s, v, w, z, v1, v3 Tdouble_t + var a, r, s, v, w, z, v1 Tdouble_t var a0, w0 float64 var big, sign int32 var hx Tuint32_t - var v2, v4 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2, v3, v4 + var v2 Tuint64_t + _, _, _, _, _, _, _, _, _, _, _, _, _ = a, a0, big, hx, r, s, sign, v, w, w0, z, v1, v2 hx = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) big = BoolInt32(hx&uint32(0x7fffffff) >= uint32(0x3FE59428)) /* |x| >= 0.6744 */ if big != 0 { @@ -101789,11 +101789,11 @@ func X__tan(tls *TLS, x float64, y float64, odd int32) (r1 float64) { v2 = *(*Tuint64_t)(unsafe.Pointer(&w0))>>Int32FromInt32(32)<>Int32FromInt32(32)<>Int32FromInt32(32)<> int32(32)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x44100000) { /* if |x| >= 2^66 */ *(*float64)(unsafe.Pointer(bp)) = x3 v1 = *(*uint64)(unsafe.Pointer(bp)) @@ -102445,11 +102445,11 @@ func Xatan(tls *TLS, x3 float64) (r float64) { } z = _atanhi[id] - (float64(x3*(s1+s2)) - _atanlo[id] - x3) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return v4 + return v3 } var _pi = float64(3.141592653589793) /* 0x400921FB, 0x54442D18 */ @@ -102464,14 +102464,14 @@ func Xatan2(tls *TLS, y float64, x float64) (r float64) { defer tls.Free(16) var __u1, __u2 Tuint64_t var ix, iy, lx, ly, m Tuint32_t - var z, v6, v7 float64 + var z, v6 float64 var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = __u1, __u2, ix, iy, lx, ly, m, z, v1, v3, v5, v6 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -102549,11 +102549,11 @@ _2: /* |y/x| > 0x1p64 */ if ix+Uint32FromInt32(Int32FromInt32(64)<>Int32FromInt32(31)&uint32(1) | ix>>Int32FromInt32(30)&uint32(2) /* 2*sign(x)+sign(y) */ - ix &= uint32(0x7fffffff) - iy &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) + iy = iy & uint32(0x7fffffff) /* when y = 0 */ if iy == uint32(0) { switch m { @@ -102666,11 +102666,11 @@ _2: /* |y/x| > 0x1p26 */ if ix+Uint32FromInt32(Int32FromInt32(26)<> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x4c800000) { /* if |x| >= 2**26 */ *(*float32)(unsafe.Pointer(bp)) = x3 v1 = *(*uint32)(unsafe.Pointer(bp)) @@ -102806,11 +102806,11 @@ func Xatanf(tls *TLS, x3 float32) (r float32) { } z = float64(_atanhi1[id]) - (Tfloat_t(float64(x3)*(s1+s2)) - float64(_atanlo1[id]) - float64(x3)) if sign != 0 { - v4 = -z + v3 = -z } else { - v4 = z + v3 = z } - return float32(v4) + return float32(v3) } // C documentation @@ -102974,12 +102974,12 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { defer tls.Free(16) var hx Tuint32_t var r, s, t, w Tdouble_t - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = hx, r, s, t, w, p1 + _, _, _, _, _, _ = hx, r, s, t, w, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103017,8 +103017,8 @@ func Xcbrt(tls *TLS, x float64) (r1 float64) { } else { hx = hx/uint32(3) + _B1 } - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) *(*Tuint64_t)(unsafe.Pointer(bp)) |= uint64(hx) << int32(32) t = *(*float64)(unsafe.Pointer(bp)) /* @@ -103269,7 +103269,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1, p2 uintptr + var v1 uintptr var _ /* ux at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 @@ -103278,7 +103278,7 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _ = p1, p2 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -103295,10 +103295,10 @@ func Xcopysign(tls *TLS, x float64, y float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp + 8)) = y - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&(Uint64FromUint64(1)<> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e46a09e) { /* |x| < 2**-27 * sqrt(2) */ @@ -103418,12 +103418,12 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { var ix Tuint32_t var n, sign uint32 var y float32 - var y1, y2, v1, v2 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2 + _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x != 0 */ @@ -103459,11 +103459,11 @@ func Xcosf(tls *TLS, x3 float32) (r float32) { if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix > uint32(0x40afeddf) { /* |x| ~> 7*pi/4 */ if sign != 0 { - v2 = float64(x3) + _c4pio2 + v1 = float64(x3) + _c4pio2 } else { - v2 = float64(x3) - _c4pio2 + v1 = float64(x3) - _c4pio2 } - return X__cosdf(tls, v2) + return X__cosdf(tls, v1) } else { if sign != 0 { return X__sindf(tls, float64(-x3)-_c3pio2) @@ -103737,7 +103737,7 @@ func Xerf(tls *TLS, x float64) (r1 float64) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float64(int32(1)-int32(2)*sign) + Float64FromInt32(1)/x @@ -103772,12 +103772,12 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float64 + var r, s, y, z, v1 float64 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float64(int32(2)*sign) + Float64FromInt32(1)/x @@ -103804,11 +103804,11 @@ func Xerfc(tls *TLS, x float64) (r1 float64) { return v1 } if sign != 0 { - v2 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) + v1 = Float64FromInt32(2) - Float64FromFloat64(2.2250738585072014e-308) } else { - v2 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) + v1 = float64(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(2.2250738585072014e-308)) } - return v2 + return v1 } var _erx1 = float32(0.84506291151) /* 0x3f58560b */ @@ -103922,7 +103922,7 @@ func Xerff(tls *TLS, x float32) (r1 float32) { _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erf(nan)=nan, erf(+-inf)=+-1 */ return float32(int32(1)-int32(2)*sign) + Float32FromInt32(1)/x @@ -103957,12 +103957,12 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { defer func() { trc("-> %v", r1) }() } var ix Tuint32_t - var r, s, y, z, v1, v2 float32 + var r, s, y, z, v1 float32 var sign int32 - _, _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1, v2 + _, _, _, _, _, _, _ = ix, r, s, sign, y, z, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { /* erfc(nan)=nan, erfc(+-inf)=0,2 */ return float32(int32(2)*sign) + Float32FromInt32(1)/x @@ -103989,11 +103989,11 @@ func Xerfcf(tls *TLS, x float32) (r1 float32) { return v1 } if sign != 0 { - v2 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) + v1 = Float32FromInt32(2) - Float32FromFloat32(7.52316384526264e-37) } else { - v2 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) + v1 = float32(Float32FromFloat32(7.52316384526264e-37) * Float32FromFloat32(7.52316384526264e-37)) } - return v2 + return v1 } func Xerfl(tls *TLS, x float64) (r float64) { @@ -104029,11 +104029,11 @@ const N = 128 // negative k means the result may underflow. */ func _specialcase(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top12(tls, float64(512))-_top12(tls, float64(5.551115123125783e-17)) { if abstop-_top12(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104120,13 +104120,13 @@ func Xexp(tls *TLS, x1 float64) (r1 float64) { z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v2 = y + v1 = y goto _3 _3: - kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp_data.Fshift + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) + kd = kd - X__exp_data.Fshift r = x1 + float64(kd*X__exp_data.Fnegln2hiN) + float64(kd*X__exp_data.Fnegln2loN) /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } const HUGE = 0 @@ -104319,11 +104319,11 @@ func Xpow10l(tls *TLS, x float64) (r float64) { // negative k means the result may underflow. */ func _specialcase1(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v5, v7 float64 - _, _, _, _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1, v3, v5, v7 + var y, y1, y2, v1 float64 + _, _, _, _, _, _, _, _ = hi, lo, scale, y, y1, y2, y3, v1 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by 1. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1)<= _top121(tls, float64(512))-_top121(tls, float64(5.551115123125783e-17)) { if abstop-_top121(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -104399,14 +104399,14 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { if !(*(*Tuint64_t)(unsafe.Pointer(&x1))>>Int32FromInt32(63) != 0) { return X__math_oflow(tls, uint32(0)) } else { - v2 = -Float64FromFloat64(1075) - if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = -Float64FromFloat64(1075) + if *(*Tuint64_t)(unsafe.Pointer(&x1)) >= *(*Tuint64_t)(unsafe.Pointer(&v1)) { return X__math_uflow(tls, uint32(0)) } } } - v3 = float64(928) - if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + v1 = float64(928) + if uint64(2)**(*Tuint64_t)(unsafe.Pointer(&x1)) > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { /* Large x is special cased below. */ abstop = uint32(0) } @@ -104414,13 +104414,13 @@ func Xexp2(tls *TLS, x1 float64) (r1 float64) { /* exp2(x) = 2^(k/N) * 2^r, with 2^r in [2^(-1/2N),2^(1/2N)]. */ /* x = k/N + r, with int k and r in [-1/2N, 1/2N]. */ y = x1 + X__exp_data.Fexp2_shift - v4 = y + v1 = y goto _5 _5: - kd = v4 - v6 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v6)) /* k. */ - kd -= X__exp_data.Fexp2_shift /* k/N for int k. */ + kd = v1 + v1 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v1)) /* k. */ + kd = kd - X__exp_data.Fexp2_shift /* k/N for int k. */ r = x1 - kd /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-65 and scale > 2^-928, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v8 = y + v1 = y goto _9 _9: - return v8 + return v1 } const EXP2F_POLY_ORDER = 3 @@ -104474,9 +104474,9 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { var abstop Tuint32_t var kd, r, r2, s, xd, y2, z Tdouble_t var ki, t Tuint64_t - var y, v1, v5 float32 - var y1, v2, v4 float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2, v4, v5 + var y, v1 float32 + var y1, v2 float64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abstop, kd, ki, r, r2, s, t, xd, y, y1, y2, z, v1, v2 xd = float64(x2) abstop = _top122(tls, x2) & uint32(0x7ff) if abstop >= _top122(tls, Float32FromFloat32(128)) { @@ -104501,13 +104501,13 @@ func Xexp2f(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift_scaled /* k/N for int k. */ + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift_scaled /* k/N for int k. */ r = xd - kd /* exp2(x) = 2^(k/N) * 2^r ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)<= _top123(tls, Float32FromFloat32(88)) { @@ -104606,13 +104606,13 @@ func Xexpf(tls *TLS, x2 float32) (r1 float32) { goto _3 _3: kd = v2 - v4 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v4)) - kd -= X__exp2f_data.Fshift + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp2f_data.Fshift r = z - kd /* exp(x) = 2^(k/N) * 2^(r/N) ~= s * (C0*r^3 + C1*r^2 + C2*r + 1) */ t = *(*Tuint64_t)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__exp2f_data)) + uintptr(ki%Uint64FromInt32(Int32FromInt32(1)< _o_threshold { - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } } @@ -104747,7 +104747,7 @@ func Xexpm1(tls *TLS, x3 float64) (r float64) { return x3 - (float64(x3*e) - hxs) } e = float64(x3*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float64(float64(0.5)*(x3-e)) - float64(0.5) @@ -104825,7 +104825,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(-Int32FromInt32(1)) } if hx > uint32(0x42b17217) { /* x > log(FLT_MAX) */ - x3 *= Float32FromFloat32(1.7014118346046923e+38) + x3 = x3 * Float32FromFloat32(1.7014118346046923e+38) return x3 } } @@ -104882,7 +104882,7 @@ func Xexpm1f(tls *TLS, x3 float32) (r float32) { return float32(float64(x3) - (Tfloat_t(float64(x3)*e) - hxs)) } e = Tfloat_t(float64(x3)*(e-c)) - c - e -= hxs + e = e - hxs /* exp(x) ~ 2^k (Xreduced - e + 1) */ if k == -int32(1) { return float32(Tfloat_t(Float64FromFloat32(0.5)*(float64(x3)-e)) - Float64FromFloat32(0.5)) @@ -104928,12 +104928,12 @@ func Xfabs(tls *TLS, x float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var p1 uintptr + var v1 uintptr var _ /* u at bp+0 */ struct { Fi [0]Tuint64_t Ff float64 } - _ = p1 + _ = v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -104942,8 +104942,8 @@ func Xfabs(tls *TLS, x float64) (r float64) { Ff float64 }{} *(*float64)(unsafe.Pointer(bp)) = x - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) / Uint64FromInt32(2))) return *(*float64)(unsafe.Pointer(bp)) } @@ -104985,13 +104985,13 @@ func Xfdim(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint64 + var v1 uint64 var v5 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105000,10 +105000,10 @@ _2: return x } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)< y { @@ -105021,13 +105021,13 @@ func Xfdimf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3 uint32 + var v1 uint32 var v5 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _ = v1, v3, v5 + _, _ = v1, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105036,10 +105036,10 @@ _2: return x } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return y } if x > y { @@ -105255,7 +105255,7 @@ func _normalize(tls *TLS, x float64) (r Tnum) { ix = *(*Tuint64_t)(unsafe.Pointer(&x)) e = Int32FromUint64(ix >> int32(52)) sign = e & int32(0x800) - e &= int32(0x7ff) + e = e & int32(0x7ff) if !(e != 0) { v1 = float64(x * float64(9.223372036854776e+18)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) @@ -105267,10 +105267,10 @@ func _normalize(tls *TLS, x float64) (r Tnum) { } e = v2 } - ix = Tuint64_t(ix & (Uint64FromUint64(1)<>int32(63) != 0 { *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = -*(*Tuint64_t)(unsafe.Pointer(bp + 8)) @@ -105383,7 +105383,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { } /* set rhi to top 63bit of the result (last bit is sticky) */ if nonzero != 0 { - e += int32(64) + e = e + int32(64) v1 = *(*Tuint64_t)(unsafe.Pointer(bp)) if v1>>Int32FromInt32(32) != 0 { y = uint32(v1 >> int32(32)) @@ -105393,24 +105393,24 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _3 @@ -105420,38 +105420,38 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp))<>(int32(64)-d) | BoolUint64(!!(*(*Tuint64_t)(unsafe.Pointer(bp + 8))<>Int32FromInt32(32) != 0 { - y = uint32(v4 >> int32(32)) + v1 = *(*Tuint64_t)(unsafe.Pointer(bp + 8)) + if v1>>Int32FromInt32(32) != 0 { + y = uint32(v1 >> int32(32)) r = Int32FromInt32(0) } else { - y = uint32(v4) + y = uint32(v1) r = Int32FromInt32(32) } if y>>Int32FromInt32(16) != 0 { - y >>= uint32(16) + y = y >> uint32(16) } else { - r |= int32(16) + r = r | int32(16) } if y>>Int32FromInt32(8) != 0 { - y >>= uint32(8) + y = y >> uint32(8) } else { - r |= int32(8) + r = r | int32(8) } if y>>Int32FromInt32(4) != 0 { - y >>= uint32(4) + y = y >> uint32(4) } else { - r |= int32(4) + r = r | int32(4) } if y>>Int32FromInt32(2) != 0 { - y >>= uint32(2) + y = y >> uint32(2) } else { - r |= int32(2) + r = r | int32(2) } - v5 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) + v2 = r | BoolInt32(!(y>>Int32FromInt32(1) != 0)) goto _6 _6: - d = v5 - int32(1) + d = v2 - int32(1) if d < 0 { *(*Tuint64_t)(unsafe.Pointer(bp)) = *(*Tuint64_t)(unsafe.Pointer(bp + 8))>>int32(1) | *(*Tuint64_t)(unsafe.Pointer(bp + 8))&uint64(1) } else { @@ -105462,7 +105462,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { return float64(x1*y1) + z } } - e -= d + e = e - d /* convert to double */ i = Int64FromUint64(*(*Tuint64_t)(unsafe.Pointer(bp))) /* i is in [1<<62,(1<<63)-1] */ if sign != 0 { @@ -105495,7 +105495,7 @@ func Xfma(tls *TLS, x1 float64, y1 float64, z float64) (r2 float64) { /* raise underflow portably, such that it cannot be optimized away */ tiny = Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) / Float64FromFloat32(1.1754943508222875e-38) * r1) - r1 += float64(Tdouble_t(tiny*tiny) * (r1 - r1)) + r1 = r1 + float64(Tdouble_t(tiny*tiny)*(r1-r1)) } } else { /* only round once when scaled */ @@ -105528,13 +105528,13 @@ func Xfmax(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105543,27 +105543,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = y } else { v9 = x @@ -105571,11 +105571,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { @@ -105585,13 +105585,13 @@ func Xfmaxf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105600,27 +105600,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeroes, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = y } else { v9 = x @@ -105628,11 +105628,11 @@ _8: return v9 } if x < y { - v12 = y + v9 = y } else { - v12 = x + v9 = x } - return v12 + return v9 } func Xfmaxl(tls *TLS, x float64, y float64) (r float64) { @@ -105650,13 +105650,13 @@ func Xfmin(tls *TLS, x float64, y float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint64 - var v12, v9 float64 + var v1, v3, v5 uint64 + var v9 float64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -105665,27 +105665,27 @@ _2: return y } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) > Uint64FromUint64(0x7ff)<>Int32FromInt32(63)) != Int32FromUint64(v7>>Int32FromInt32(63)) { + if Int32FromUint64(v1>>Int32FromInt32(63)) != Int32FromUint64(v3>>Int32FromInt32(63)) { *(*float64)(unsafe.Pointer(bp)) = x - v10 = *(*uint64)(unsafe.Pointer(bp)) + v5 = *(*uint64)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint64(v10>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v5>>Int32FromInt32(63)) != 0 { v9 = x } else { v9 = y @@ -105693,11 +105693,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminf(tls *TLS, x float32, y float32) (r float32) { @@ -105707,13 +105707,13 @@ func Xfminf(tls *TLS, x float32, y float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v10, v3, v5, v7 uint32 - var v12, v9 float32 + var v1, v3, v5 uint32 + var v9 float32 var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _, _, _, _ = v1, v10, v12, v3, v5, v7, v9 + _, _, _, _ = v1, v3, v5, v9 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -105722,27 +105722,27 @@ _2: return y } *(*float32)(unsafe.Pointer(bp)) = y - v3 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _4 _4: - if BoolInt32(v3&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { + if BoolInt32(v1&uint32(0x7fffffff) > uint32(0x7f800000)) != 0 { return x } /* handle signed zeros, see C99 Annex F.9.9.2 */ *(*float32)(unsafe.Pointer(bp)) = x - v5 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _6 _6: *(*float32)(unsafe.Pointer(bp)) = y - v7 = *(*uint32)(unsafe.Pointer(bp)) + v3 = *(*uint32)(unsafe.Pointer(bp)) goto _8 _8: - if Int32FromUint32(v5>>Int32FromInt32(31)) != Int32FromUint32(v7>>Int32FromInt32(31)) { + if Int32FromUint32(v1>>Int32FromInt32(31)) != Int32FromUint32(v3>>Int32FromInt32(31)) { *(*float32)(unsafe.Pointer(bp)) = x - v10 = *(*uint32)(unsafe.Pointer(bp)) + v5 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { + if Int32FromUint32(v5>>Int32FromInt32(31)) != 0 { v9 = x } else { v9 = y @@ -105750,11 +105750,11 @@ _8: return v9 } if x < y { - v12 = x + v9 = x } else { - v12 = y + v9 = y } - return v12 + return v9 } func Xfminl(tls *TLS, x float64, y float64) (r float64) { @@ -105776,7 +105776,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { var i, uxi Tuint64_t var v1 uint64 var v3 bool - var p6, p7 uintptr + var v6 uintptr var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -105789,7 +105789,7 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, p6, p7 + _, _, _, _, _, _, _, _ = ex, ey, i, sx, uxi, v1, v3, v6 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -105837,13 +105837,13 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _4 _4: ; - ex-- - i <<= uint64(1) + ex = ex - 1 + i = i << uint64(1) } - uxi <<= Uint64FromInt32(-ex + int32(1)) + uxi = uxi << Uint64FromInt32(-ex+int32(1)) } else { - uxi = Tuint64_t(uxi & (-Uint64FromUint64(1) >> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { @@ -105896,17 +105896,17 @@ func Xfmod(tls *TLS, x float64, y float64) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } /* scale result */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } - uxi |= Uint64FromInt32(sx) << int32(63) + uxi = uxi | Uint64FromInt32(sx)<> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { @@ -106037,17 +106037,17 @@ func Xfmodf(tls *TLS, x float32, y float32) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } /* scale result up */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } - uxi |= sx + uxi = uxi | sx *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi return *(*float32)(unsafe.Pointer(bp + 4)) } @@ -106068,12 +106068,12 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint64_t Fd float64 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint64_t Fd float64 @@ -106097,10 +106097,10 @@ func Xfrexp(tls *TLS, x float64, e uintptr) (r float64) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x3fe) - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & Uint64FromUint64(0x800fffffffffffff)) - p2 = bp - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) | Uint64FromUint64(0x3fe0000000000000)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & Uint64FromUint64(0x800fffffffffffff)) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) | Uint64FromUint64(0x3fe0000000000000)) return *(*float64)(unsafe.Pointer(bp)) } @@ -106112,12 +106112,12 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { bp := tls.Alloc(16) defer tls.Free(16) var ee int32 - var p1, p2 uintptr + var v1 uintptr var _ /* y at bp+0 */ struct { Fi [0]Tuint32_t Ff float32 } - _, _, _ = ee, p1, p2 + _, _ = ee, v1 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -106141,10 +106141,10 @@ func Xfrexpf(tls *TLS, x float32, e uintptr) (r float32) { } } *(*int32)(unsafe.Pointer(e)) = ee - int32(0x7e) - p1 = bp - *(*Tuint32_t)(unsafe.Pointer(p1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p1))) & Uint64FromUint64(0x807fffff)) - p2 = bp - *(*Tuint32_t)(unsafe.Pointer(p2)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(p2))) | Uint64FromUint64(0x3f000000)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) & Uint64FromUint64(0x807fffff)) + v1 = bp + *(*Tuint32_t)(unsafe.Pointer(v1)) = Tuint32_t(uint64(*(*Tuint32_t)(unsafe.Pointer(v1))) | Uint64FromUint64(0x3f000000)) return *(*float32)(unsafe.Pointer(bp)) } @@ -106181,7 +106181,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Ff float64 } var z Tdouble_t - var p1, p2 uintptr + var v1 uintptr var _ /* hx at bp+16 */ Tdouble_t var _ /* hy at bp+32 */ Tdouble_t var _ /* lx at bp+24 */ Tdouble_t @@ -106194,7 +106194,7 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { Fi [0]Tuint64_t Ff float64 } - _, _, _, _, _, _ = ex, ey, ut, z, p1, p2 + _, _, _, _, _ = ex, ey, ut, z, v1 *(*struct { Fi [0]Tuint64_t Ff float64 @@ -106212,10 +106212,10 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { }{} *(*float64)(unsafe.Pointer(bp + 8)) = y /* arrange |x| >= |y| */ - p1 = bp - *(*Tuint64_t)(unsafe.Pointer(p1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) - p2 = bp + 8 - *(*Tuint64_t)(unsafe.Pointer(p2)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p2)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) + v1 = bp + 8 + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (-Uint64FromUint64(1) >> Int32FromInt32(1))) if *(*Tuint64_t)(unsafe.Pointer(bp)) < *(*Tuint64_t)(unsafe.Pointer(bp + 8)) { ut = *(*struct { Fi [0]Tuint64_t @@ -106255,13 +106255,13 @@ func Xhypot(tls *TLS, x float64, y float64) (r float64) { z = Float64FromInt32(1) if ex > Int32FromInt32(0x3ff)+Int32FromInt32(510) { z = float64(5.260135901548374e+210) - x *= float64(1.90109156629516e-211) - y *= float64(1.90109156629516e-211) + x = x * float64(1.90109156629516e-211) + y = y * float64(1.90109156629516e-211) } else { if ey < Int32FromInt32(0x3ff)-Int32FromInt32(450) { z = float64(1.90109156629516e-211) - x *= float64(5.260135901548374e+210) - y *= float64(5.260135901548374e+210) + x = x * float64(5.260135901548374e+210) + y = y * float64(5.260135901548374e+210) } } _sq(tls, bp+16, bp+24, x) @@ -106336,13 +106336,13 @@ func Xhypotf(tls *TLS, x float32, y float32) (r float32) { z = Float64FromInt32(1) if *(*Tuint32_t)(unsafe.Pointer(bp)) >= Uint32FromInt32((Int32FromInt32(0x7f)+Int32FromInt32(60))<> int32(52) & uint64(0x7ff)) if !(e != 0) { - i <<= uint64(12) + i = i << uint64(12) if i == uint64(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106405,8 +106405,8 @@ func Xilogb(tls *TLS, x3 float64) (r int32) { goto _1 _1: ; - e-- - i <<= uint64(1) + e = e - 1 + i = i << uint64(1) } return e } @@ -106457,7 +106457,7 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { i = *(*Tuint32_t)(unsafe.Pointer(bp)) e = Int32FromUint32(i >> int32(23) & uint32(0xff)) if !(e != 0) { - i <<= uint32(9) + i = i << uint32(9) if i == uint32(0) { if uint64(4) == uint64(4) { y = Float32FromInt32(0) / Float32FromFloat32(0) @@ -106479,8 +106479,8 @@ func Xilogbf(tls *TLS, x3 float32) (r int32) { goto _1 _1: ; - e-- - i <<= uint32(1) + e = e - 1 + i = i << uint32(1) } return e } @@ -106576,7 +106576,7 @@ func Xj0(tls *TLS, x float64) (r1 float64) { var r, s, z float64 _, _, _, _ = ix, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* j0(+-inf)=0, j0(nan)=nan */ if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) @@ -106732,7 +106732,7 @@ func _pzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pR8)) q = uintptr(unsafe.Pointer(&_pS8)) @@ -106840,7 +106840,7 @@ func _qzero(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qR8)) q = uintptr(unsafe.Pointer(&_qS8)) @@ -106920,7 +106920,7 @@ func Xj0f(tls *TLS, x float32) (r1 float32) { var r, s, z float32 _, _, _, _ = ix, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107065,7 +107065,7 @@ func _pzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pR81)) q = uintptr(unsafe.Pointer(&_pS81)) @@ -107173,7 +107173,7 @@ func _qzerof(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qR81)) q = uintptr(unsafe.Pointer(&_qS81)) @@ -107264,7 +107264,7 @@ func Xj1(tls *TLS, x float64) (r1 float64) { _, _, _, _, _ = ix, r, s, sign, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7ff00000) { return Float64FromInt32(1) / float64(x*x) } @@ -107411,7 +107411,7 @@ func _pone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_pr8)) q = uintptr(unsafe.Pointer(&_ps8)) @@ -107518,7 +107518,7 @@ func _qone(tls *TLS, x float64) (r1 float64) { var r, s, z Tdouble_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x40200000) { p = uintptr(unsafe.Pointer(&_qr8)) q = uintptr(unsafe.Pointer(&_qs8)) @@ -107600,7 +107600,7 @@ func Xj1f(tls *TLS, x float32) (r1 float32) { _, _, _, _, _ = ix, r, s, sign, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x7f800000) { return Float32FromInt32(1) / float32(x*x) } @@ -107742,7 +107742,7 @@ func _ponef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_pr81)) q = uintptr(unsafe.Pointer(&_ps81)) @@ -107849,7 +107849,7 @@ func _qonef(tls *TLS, x float32) (r1 float32) { var r, s, z Tfloat_t _, _, _, _, _, _ = ix, p, q, r, s, z ix = *(*Tuint32_t)(unsafe.Pointer(&x)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix >= uint32(0x41000000) { p = uintptr(unsafe.Pointer(&_qr81)) q = uintptr(unsafe.Pointer(&_qs81)) @@ -107889,7 +107889,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -107903,14 +107903,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabs(tls, x) if ix|lx == uint32(0) || ix == uint32(0x7ff00000) { /* if x is 0 or inf */ b = float64(0) @@ -107953,7 +107953,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float64(b*(float64(float64(2)*float64(i))/x)) - a /* avoid underflow */ a = temp @@ -107977,12 +107977,12 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { if !(i <= nm1+int32(1)) { break } - a *= float64(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float64(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } @@ -107995,8 +107995,8 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { q1 = float64(w*z) - float64(1) k = int32(1) for q1 < float64(1e+09) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float64(z*q1) - q0 q0 = q1 q1 = tmp @@ -108011,7 +108011,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = float64(1) @@ -108036,7 +108036,7 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108049,14 +108049,14 @@ func Xjn(tls *TLS, n int32, x float64) (r float64) { a = temp /* scale b to avoid spurious overflow */ if b > float64(3.273390607896142e+150) { - a /= b - t /= b + a = a / b + t = t / b b = float64(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0(tls, x) @@ -108083,15 +108083,15 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { defer func() { trc("-> %v", r) }() } var __u Tuint64_t - var a, b, temp, v1, v3 float64 + var a, b, temp, v1 float64 var i, nm1, sign int32 var ib, ix, lx Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = __u, a, b, i, ib, ix, lx, nm1, sign, temp, v1 __u = *(*Tuint64_t)(unsafe.Pointer(&x)) ix = uint32(__u >> int32(32)) lx = uint32(__u) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix|(lx|-lx)>>int32(31) > uint32(0x7ff00000) { /* nan */ return x } @@ -108157,7 +108157,7 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { if !(i < nm1 && ib != uint32(0xfff00000)) { break } - i++ + i = i + 1 temp = b b = float64(float64(float64(2)*float64(i))/x*b) - a ib = uint32(*(*Tuint64_t)(unsafe.Pointer(&b)) >> int32(32)) @@ -108167,11 +108167,11 @@ func Xyn(tls *TLS, n int32, x float64) (r float64) { } } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xjnf(tls *TLS, n int32, x float32) (r float32) { @@ -108185,7 +108185,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, h, i, ix, k, nf, nm1, q0, q1, sign, t, temp, tmp, w, z, v6 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108196,14 +108196,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if n < 0 { nm1 = -(n + int32(1)) x = -x - sign ^= int32(1) + sign = sign ^ int32(1) } else { nm1 = n - int32(1) } if nm1 == 0 { return Xj1f(tls, x) } - sign &= n /* even n: 0, odd n: signbit(x) */ + sign = sign & n /* even n: 0, odd n: signbit(x) */ x = Xfabsf(tls, x) if ix == uint32(0) || ix == uint32(0x7f800000) { /* if x is 0 or inf */ b = Float32FromFloat32(0) @@ -108217,7 +108217,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1) { break } - i++ + i = i + 1 temp = b b = float32(b*(float32(Float32FromFloat32(2)*float32(i))/x)) - a a = temp @@ -108240,12 +108240,12 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { if !(i <= nm1+int32(1)) { break } - a *= float32(i) /* a = n! */ - b *= temp /* b = (x/2)^n */ + a = a * float32(i) /* a = n! */ + b = b * temp /* b = (x/2)^n */ goto _2 _2: ; - i++ + i = i + 1 } b = b / a } else { @@ -108257,8 +108257,8 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { q1 = float32(w*z) - Float32FromFloat32(1) k = int32(1) for q1 < Float32FromFloat32(10000) { - k += int32(1) - z += h + k = k + int32(1) + z = z + h tmp = float32(z*q1) - q0 q0 = q1 q1 = tmp @@ -108273,7 +108273,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _3 _3: ; - i-- + i = i - 1 } a = t b = Float32FromFloat32(1) @@ -108298,7 +108298,7 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { goto _4 _4: ; - i-- + i = i - 1 } } else { i = nm1 @@ -108311,14 +108311,14 @@ func Xjnf(tls *TLS, n int32, x float32) (r float32) { a = temp /* scale b to avoid spurious overflow */ if b > Float32FromFloat32(1.152921504606847e+18) { - a /= b - t /= b + a = a / b + t = t / b b = Float32FromFloat32(1) } goto _5 _5: ; - i-- + i = i - 1 } } z = Xj0f(tls, x) @@ -108344,13 +108344,13 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { trc("tls=%v n=%v x=%v, (%v:)", tls, n, x, origin(2)) defer func() { trc("-> %v", r) }() } - var a, b, temp, v1, v3 float32 + var a, b, temp, v1 float32 var i, nm1, sign int32 var ib, ix Tuint32_t - _, _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1, v3 + _, _, _, _, _, _, _, _, _ = a, b, i, ib, ix, nm1, sign, temp, v1 ix = *(*Tuint32_t)(unsafe.Pointer(&x)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix > uint32(0x7f800000) { /* nan */ return x } @@ -108387,7 +108387,7 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { if !(i < nm1 && ib != uint32(0xff800000)) { break } - i++ + i = i + 1 temp = b b = float32(float32(Float32FromFloat32(2)*float32(i))/x*b) - a ib = *(*Tuint32_t)(unsafe.Pointer(&b)) @@ -108396,11 +108396,11 @@ func Xynf(tls *TLS, n int32, x float32) (r float32) { _2: } if sign != 0 { - v3 = -b + v1 = -b } else { - v3 = b + v1 = b } - return v3 + return v1 } func Xldexp(tls *TLS, x float64, n int32) (r float64) { @@ -108509,8 +108509,8 @@ func _sin_pi(tls *TLS, x float64) (r float64) { x = float64(float64(2) * (float64(x*float64(0.5)) - Xfloor(tls, float64(x*float64(0.5))))) /* x mod 2.0 */ n = int32(float64(x * Float64FromFloat64(4))) n = (n + int32(1)) / int32(2) - x -= float64(float32(n) * Float32FromFloat32(0.5)) - x *= _pi2 + x = x - float64(float32(n)*Float32FromFloat32(0.5)) + x = x * _pi2 switch n { default: /* case 4: */ fallthrough @@ -108616,7 +108616,7 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p1 = _a0 + float64(z*(_a2+float64(z*(_a4+float64(z*(_a6+float64(z*(_a8+float64(z*_a10))))))))) p2 = Tdouble_t(z * (_a1 + float64(z*(_a3+float64(z*(_a5+float64(z*(_a7+float64(z*(_a9+float64(z*_a11))))))))))) p = Tdouble_t(y*p1) + p2 - r += p - Tdouble_t(float64(0.5)*y) + r = r + (p - Tdouble_t(float64(0.5)*y)) case int32(1): z = Tdouble_t(y * y) w = Tdouble_t(z * y) @@ -108624,11 +108624,11 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { p2 = _t1 + float64(w*(_t4+float64(w*(_t7+float64(w*(_t10+float64(w*_t13))))))) p3 = _t2 + float64(w*(_t5+float64(w*(_t8+float64(w*(_t11+float64(w*_t14))))))) p = Tdouble_t(z*p1) - (_tt - float64(w*(p2+Tdouble_t(y*p3)))) - r += _tf + p + r = r + (_tf + p) case int32(2): p1 = Tdouble_t(y * (_u0 + float64(y*(_u1+float64(y*(_u2+float64(y*(_u3+float64(y*(_u4+float64(y*_u5))))))))))) p2 = float64(1) + float64(y*(_v1+float64(y*(_v2+float64(y*(_v3+float64(y*(_v4+float64(y*_v5))))))))) - r += float64(-Float64FromFloat64(0.5)*y) + p1/p2 + r = r + (float64(-Float64FromFloat64(0.5)*y) + p1/p2) } } else { if ix < uint32(0x40200000) { /* x < 8.0 */ @@ -108640,20 +108640,20 @@ func X__lgamma_r(tls *TLS, x float64, signgamp uintptr) (r1 float64) { z = float64(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + float64(6) /* FALLTHRU */ + z = z * (y + float64(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + float64(5) /* FALLTHRU */ + z = z * (y + float64(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + float64(4) /* FALLTHRU */ + z = z * (y + float64(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + float64(3) /* FALLTHRU */ + z = z * (y + float64(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + float64(2) /* FALLTHRU */ - r += Xlog(tls, z) + z = z * (y + float64(2)) /* FALLTHRU */ + r = r + Xlog(tls, z) break } } else { @@ -108767,7 +108767,7 @@ func _sin_pi1(tls *TLS, x float32) (r float32) { n = int32(float32(x * Float32FromInt32(4))) n = (n + int32(1)) / int32(2) y = float64(x - float32(float32(n)*Float32FromFloat32(0.5))) - y *= float64(3.141592653589793) + y = y * float64(3.141592653589793) switch n { default: /* case 4: */ fallthrough @@ -108873,7 +108873,7 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p1 = _a01 + float32(z*(_a21+float32(z*(_a41+float32(z*(_a61+float32(z*(_a81+float32(z*_a101))))))))) p2 = float32(z * (_a12 + float32(z*(_a31+float32(z*(_a51+float32(z*(_a71+float32(z*(_a91+float32(z*_a111))))))))))) p = float32(y*p1) + p2 - r += p - float32(Float32FromFloat32(0.5)*y) + r = r + (p - float32(Float32FromFloat32(0.5)*y)) case int32(1): z = float32(y * y) w = float32(z * y) @@ -108881,11 +108881,11 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { p2 = _t15 + float32(w*(_t41+float32(w*(_t71+float32(w*(_t101+float32(w*_t131))))))) p3 = _t21 + float32(w*(_t51+float32(w*(_t81+float32(w*(_t111+float32(w*_t141))))))) p = float32(z*p1) - (_tt1 - float32(w*(p2+float32(y*p3)))) - r += _tf1 + p + r = r + (_tf1 + p) case int32(2): p1 = float32(y * (_u07 + float32(y*(_u11+float32(y*(_u21+float32(y*(_u31+float32(y*(_u41+float32(y*_u51))))))))))) p2 = Float32FromFloat32(1) + float32(y*(_v11+float32(y*(_v21+float32(y*(_v31+float32(y*(_v41+float32(y*_v51))))))))) - r += float32(-Float32FromFloat32(0.5)*y) + p1/p2 + r = r + (float32(-Float32FromFloat32(0.5)*y) + p1/p2) } } else { if ix < uint32(0x41000000) { /* x < 8.0 */ @@ -108897,20 +108897,20 @@ func X__lgammaf_r(tls *TLS, x float32, signgamp uintptr) (r1 float32) { z = Float32FromFloat32(1) /* lgamma(1+s) = log(s) + lgamma(s) */ switch i { case int32(7): - z *= y + Float32FromFloat32(6) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(6)) /* FALLTHRU */ fallthrough case int32(6): - z *= y + Float32FromFloat32(5) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(5)) /* FALLTHRU */ fallthrough case int32(5): - z *= y + Float32FromFloat32(4) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(4)) /* FALLTHRU */ fallthrough case int32(4): - z *= y + Float32FromFloat32(3) /* FALLTHRU */ + z = z * (y + Float32FromFloat32(3)) /* FALLTHRU */ fallthrough case int32(3): - z *= y + Float32FromFloat32(2) /* FALLTHRU */ - r += Xlogf(tls, z) + z = z * (y + Float32FromFloat32(2)) /* FALLTHRU */ + r = r + Xlogf(tls, z) break } } else { @@ -109038,9 +109038,9 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, r, r2, r3, rhi, rlo, tmp, top, w, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top16(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.0625) @@ -109066,31 +109066,31 @@ func Xlog(tls *TLS, x1 float64) (r1 float64) { w = Tdouble_t(Tdouble_t(rhi*rhi) * *(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))) /* B[0] == -0.5. */ hi = r + w lo = r - hi + w - lo += Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo) * (rhi + r)) - y1 += lo - y1 += hi + lo = lo + Tdouble_t(float64(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log_data)) + 56))*rlo)*(rhi+r)) + y1 = y1 + lo + y1 = y1 + hi y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> int32(32)) } else { @@ -109190,8 +109190,8 @@ func Xlog10(tls *TLS, x float64) (r float64) { } } /* reduce x into [sqrt(2)/2, sqrt(2)] */ - hx += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) - k += Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff) + hx = hx + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) + k = k + (Int32FromUint32(hx>>Int32FromInt32(20)) - int32(0x3ff)) hx = hx&uint32(0x000fffff) + uint32(0x3fe6a09e) *(*Tuint64_t)(unsafe.Pointer(bp)) = uint64(hx)<>Int32FromInt32(23)) - int32(0x7f) + ix = ix + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) + k = k + (Int32FromUint32(ix>>Int32FromInt32(23)) - int32(0x7f)) ix = ix&uint32(0x007fffff) + uint32(0x3f3504f3) *(*Tuint32_t)(unsafe.Pointer(bp)) = ix x = *(*float32)(unsafe.Pointer(bp)) @@ -109386,7 +109386,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { if k != 0 { *(*float64)(unsafe.Pointer(bp)) = Float64FromInt32(1) + x3 hu = uint32(*(*Tuint64_t)(unsafe.Pointer(bp)) >> int32(32)) - hu += Uint32FromInt32(Int32FromInt32(0x3ff00000) - Int32FromInt32(0x3fe6a09e)) + hu = hu + Uint32FromInt32(Int32FromInt32(0x3ff00000)-Int32FromInt32(0x3fe6a09e)) k = Int32FromUint32(hu>>Int32FromInt32(20)) - int32(0x3ff) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(54) { @@ -109396,7 +109396,7 @@ func Xlog1p(tls *TLS, x3 float64) (r float64) { v1 = x3 - (*(*float64)(unsafe.Pointer(bp)) - Float64FromInt32(1)) } c = v1 - c /= *(*float64)(unsafe.Pointer(bp)) + c = c / *(*float64)(unsafe.Pointer(bp)) } else { c = Float64FromInt32(0) } @@ -109486,7 +109486,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { if k != 0 { *(*float32)(unsafe.Pointer(bp)) = Float32FromInt32(1) + x3 iu = *(*Tuint32_t)(unsafe.Pointer(bp)) - iu += Uint32FromInt32(Int32FromInt32(0x3f800000) - Int32FromInt32(0x3f3504f3)) + iu = iu + Uint32FromInt32(Int32FromInt32(0x3f800000)-Int32FromInt32(0x3f3504f3)) k = Int32FromUint32(iu>>Int32FromInt32(23)) - int32(0x7f) /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */ if k < int32(25) { @@ -109496,7 +109496,7 @@ func Xlog1pf(tls *TLS, x3 float32) (r float32) { v1 = x3 - (*(*float32)(unsafe.Pointer(bp)) - Float32FromInt32(1)) } c = float64(v1) - c /= float64(*(*float32)(unsafe.Pointer(bp))) + c = c / float64(*(*float32)(unsafe.Pointer(bp))) } else { c = Float64FromInt32(0) } @@ -109545,9 +109545,9 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { var i, k int32 var ix, iz, tmp Tuint64_t var top Tuint32_t - var y, v1, v10, v2, v3, v4, v6, v8, v9 float64 + var y, v1, v2, v3, v4 float64 var v5 bool - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v10, v2, v3, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, i, invc, ix, iz, k, kd, lo, logc, p, r, r2, r4, t1, t2, t3, tmp, top, y, y1, z, v1, v2, v3, v4, v5 ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = _top161(tls, x1) v1 = Float64FromFloat64(1) - Float64FromFloat64(0.04239702224731445) @@ -109570,31 +109570,31 @@ func Xlog2(tls *TLS, x1 float64) (r1 float64) { /* Worst-case error is less than 0.54 ULP (0.55 ULP without fma). */ p = Tdouble_t(r2 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 1*8))))) y1 = hi + p - lo += hi - y1 + p - lo += Tdouble_t(r4 * (*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8)) + float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8))) + float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8))))) + float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) - y1 += lo + lo = lo + (hi - y1 + p) + lo = lo + Tdouble_t(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 2*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 3*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 4*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 5*8)))))+float64(r4*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 6*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 7*8)))+float64(r2*(*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 8*8))+float64(r**(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__log2_data)) + 64 + 9*8))))))))) + y1 = y1 + lo y = y1 - v6 = y + v1 = y goto _7 _7: - return v6 + return v1 } if top-uint32(0x0010) >= Uint32FromInt32(Int32FromInt32(0x7ff0)-Int32FromInt32(0x0010)) { /* x < 0x1p-1022 or inf or nan. */ if ix*uint64(2) == uint64(0) { return X__math_divzero(tls, uint32(1)) } - v8 = float64(X__builtin_inff(tls)) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v8)) { /* log(inf) == inf. */ + v1 = float64(X__builtin_inff(tls)) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { /* log(inf) == inf. */ return x1 } if top&uint32(0x8000) != 0 || top&uint32(0x7ff0) == uint32(0x7ff0) { return X__math_invalid(tls, x1) } /* x is subnormal, normalize it. */ - v9 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v9)) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12) >> e) if *(*Tuint64_t)(unsafe.Pointer(bp))&mask == uint64(0) { *(*float64)(unsafe.Pointer(iptr)) = x - p3 = bp - *(*Tuint64_t)(unsafe.Pointer(p3)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p3)) & (Uint64FromUint64(1) << Int32FromInt32(63))) + v1 = bp + *(*Tuint64_t)(unsafe.Pointer(v1)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v1)) & (Uint64FromUint64(1) << Int32FromInt32(63))) return *(*float64)(unsafe.Pointer(bp)) } *(*Tuint64_t)(unsafe.Pointer(bp)) &= ^mask @@ -110213,9 +110213,9 @@ _2: *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uint64(*(*Tuint64_t)(unsafe.Pointer(bp + 16))&(Uint64FromUint64(1)< ay || (*(*Tuint64_t)(unsafe.Pointer(bp + 8))^*(*Tuint64_t)(unsafe.Pointer(bp + 16)))&(Uint64FromUint64(1)<> int32(52) & uint64(0x7ff)) @@ -110313,9 +110313,9 @@ _2: *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 8))&uint32(0x80000000) | uint32(1) } else { if ax > ay || (*(*Tuint32_t)(unsafe.Pointer(bp + 4))^*(*Tuint32_t)(unsafe.Pointer(bp + 8)))&uint32(0x80000000) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 4))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) + 1 } } e = *(*Tuint32_t)(unsafe.Pointer(bp + 4)) & uint32(0x7f800000) @@ -110372,8 +110372,8 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { var e Tuint32_t var y float32 var y1, y2 float64 - var v1, v10, v8 uint32 - var v3, v6 uint64 + var v1 uint32 + var v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 @@ -110387,7 +110387,7 @@ func Xnexttowardf(tls *TLS, x3 float32, y3 float64) (r float32) { Fi [0]Tuint32_t Ff float32 } - _, _, _, _, _, _, _, _, _, _ = e, y, y1, y2, v1, v10, v3, v5, v6, v8 + _, _, _, _, _, _, _ = e, y, y1, y2, v1, v3, v5 *(*struct { Fi [0]Tuint32_t Ff float32 @@ -110416,32 +110416,32 @@ _2: if x3 == Float32FromInt32(0) { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = uint32(1) *(*float64)(unsafe.Pointer(bp + 8)) = y3 - v6 = *(*uint64)(unsafe.Pointer(bp + 8)) + v3 = *(*uint64)(unsafe.Pointer(bp + 8)) goto _7 _7: - if Int32FromUint64(v6>>Int32FromInt32(63)) != 0 { + if Int32FromUint64(v3>>Int32FromInt32(63)) != 0 { *(*Tuint32_t)(unsafe.Pointer(bp + 16)) |= uint32(0x80000000) } } else { if float64(x3) < y3 { *(*float32)(unsafe.Pointer(bp)) = x3 - v8 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _9 _9: - if Int32FromUint32(v8>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } } else { *(*float32)(unsafe.Pointer(bp)) = x3 - v10 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _11 _11: - if Int32FromUint32(v10>>Int32FromInt32(31)) != 0 { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))++ + if Int32FromUint32(v1>>Int32FromInt32(31)) != 0 { + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) + 1 } else { - *(*Tuint32_t)(unsafe.Pointer(bp + 16))-- + *(*Tuint32_t)(unsafe.Pointer(bp + 16)) = *(*Tuint32_t)(unsafe.Pointer(bp + 16)) - 1 } } } @@ -110571,12 +110571,12 @@ func _log_inline(tls *TLS, ix Tuint64_t, tail uintptr) (r1 Tdouble_t) { // negative k means the result may underflow. */ func _specialcase2(tls *TLS, tmp Tdouble_t, sbits Tuint64_t, ki Tuint64_t) (r float64) { var hi, lo, one, scale, y3 Tdouble_t - var y, y1, y2, v1, v3, v6, v8 float64 + var y, y1, y2, v1 float64 var v5 Tuint64_t - _, _, _, _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v3, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _ = hi, lo, one, scale, y, y1, y2, y3, v1, v5 if ki&uint64(0x80000000) == uint64(0) { /* k > 0, the exponent of scale might have overflowed by <= 460. */ - sbits = Tuint64_t(sbits - Uint64FromUint64(1009)<= _top124(tls, float64(512))-_top124(tls, float64(5.551115123125783e-17)) { if abstop-_top124(tls, float64(5.551115123125783e-17)) >= uint32(0x80000000) { @@ -110663,16 +110663,16 @@ func _exp_inline(tls *TLS, x1 Tdouble_t, xtail Tdouble_t, sign_bias Tuint32_t) ( z = Tdouble_t(X__exp_data.Finvln2N * x1) /* z - kd is in [-1, 1] in non-nearest rounding modes. */ y = z + X__exp_data.Fshift - v3 = y + v2 = y goto _4 _4: - kd = v3 - v5 = kd - ki = *(*Tuint64_t)(unsafe.Pointer(&v5)) - kd -= X__exp_data.Fshift + kd = v2 + v2 = kd + ki = *(*Tuint64_t)(unsafe.Pointer(&v2)) + kd = kd - X__exp_data.Fshift r = x1 + Tdouble_t(kd*X__exp_data.Fnegln2hiN) + Tdouble_t(kd*X__exp_data.Fnegln2loN) /* The code assumes 2^-200 < |xtail| < 2^-8/N. */ - r += xtail + r = r + xtail /* 2^(k/N) ~= scale * (1 + tail). */ idx = uint64(2) * (ki % Uint64FromInt32(Int32FromInt32(1)< 2^-200 and scale > 2^-739, so there is no spurious underflow here even without fma. */ y = scale + Tdouble_t(scale*tmp) - v7 = y + v2 = y goto _8 _8: - return v7 + return v2 } // C documentation @@ -110742,11 +110742,11 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { var ehi, elo, hi, x2 Tdouble_t var ix, iy Tuint64_t var sign_bias, topx, topy Tuint32_t - var y, v1, v10, v11, v12, v13, v14, v15, v2, v3, v5, v6, v7, v8 float64 + var y, v1, v2 float64 var yint int32 var v4 bool var _ /* lo at bp+0 */ Tdouble_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v10, v11, v12, v13, v14, v15, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ehi, elo, hi, ix, iy, sign_bias, topx, topy, x2, y, yint, v1, v2, v4 sign_bias = uint32(0) ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) iy = *(*Tuint64_t)(unsafe.Pointer(&y1)) @@ -110765,19 +110765,19 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v2 = float64(X__builtin_inff(tls)) - if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)); !v4 { - v3 = float64(X__builtin_inff(tls)) + v1 = float64(X__builtin_inff(tls)) + if v4 = uint64(2)*ix > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)); !v4 { + v2 = float64(X__builtin_inff(tls)) } - if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v3)) { + if v4 || uint64(2)*iy > uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v2)) { return x1 + y1 } - v5 = float64(1) - if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v5)) { + v1 = float64(1) + if uint64(2)*ix == uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } - v6 = float64(1) - if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v6))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { + v1 = float64(1) + if BoolInt32(uint64(2)*ix < uint64(2)**(*Tuint64_t)(unsafe.Pointer(&v1))) == BoolInt32(!(iy>>Int32FromInt32(63) != 0)) { return float64(0) } /* |x|<1 && y==inf or |x|>1 && y==-inf. */ return float64(y1 * y1) @@ -110791,14 +110791,14 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { thus division by zero exception can be signaled spuriously. */ if iy>>int32(63) != 0 { y = Float64FromInt32(1) / x2 - v8 = y + v2 = y goto _9 _9: - v7 = v8 + v1 = v2 } else { - v7 = x2 + v1 = x2 } - return v7 + return v1 } /* Here x and y are non-zero finite. */ if ix>>int32(63) != 0 { @@ -110810,43 +110810,43 @@ func Xpow(tls *TLS, x1 float64, y1 float64) (r float64) { if yint == int32(1) { sign_bias = Uint32FromInt32(Int32FromInt32(0x800) << Int32FromInt32(EXP_TABLE_BITS)) } - ix &= uint64(0x7fffffffffffffff) - topx &= uint32(0x7ff) + ix = ix & uint64(0x7fffffffffffffff) + topx = topx & uint32(0x7ff) } if topy&uint32(0x7ff)-uint32(0x3be) >= Uint32FromInt32(Int32FromInt32(0x43e)-Int32FromInt32(0x3be)) { /* Note: sign_bias == 0 here because y is not odd. */ - v10 = float64(1) - if ix == *(*Tuint64_t)(unsafe.Pointer(&v10)) { + v1 = float64(1) + if ix == *(*Tuint64_t)(unsafe.Pointer(&v1)) { return float64(1) } if topy&uint32(0x7ff) < uint32(0x3be) { /* |y| < 2^-65, x^y ~= 1 + y*log(x). */ if int32(WANT_ROUNDING) != 0 { - v12 = float64(1) - if ix > *(*Tuint64_t)(unsafe.Pointer(&v12)) { - v11 = float64(1) + y1 + v2 = float64(1) + if ix > *(*Tuint64_t)(unsafe.Pointer(&v2)) { + v1 = float64(1) + y1 } else { - v11 = float64(1) - y1 + v1 = float64(1) - y1 } - return v11 + return v1 } else { return float64(1) } } - v14 = float64(1) - if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v14))) == BoolInt32(topy < uint32(0x800)) { - v13 = X__math_oflow(tls, uint32(0)) + v2 = float64(1) + if BoolInt32(ix > *(*Tuint64_t)(unsafe.Pointer(&v2))) == BoolInt32(topy < uint32(0x800)) { + v1 = X__math_oflow(tls, uint32(0)) } else { - v13 = X__math_uflow(tls, uint32(0)) + v1 = X__math_uflow(tls, uint32(0)) } - return v13 + return v1 } if topx == uint32(0) { /* Normalize subnormal x so exponent becomes negative. */ - v15 = float64(x1 * float64(4.503599627370496e+15)) - ix = *(*Tuint64_t)(unsafe.Pointer(&v15)) - ix &= uint64(0x7fffffffffffffff) - ix = Tuint64_t(ix - Uint64FromUint64(52)<> Int32FromInt32(12))) - uxi = Tuint64_t(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) + uxi = uint64(uxi | Uint64FromUint64(1)<> Int32FromInt32(12))) - p7 = bp + 16 - *(*Tuint64_t)(unsafe.Pointer(p7)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(p7)) | Uint64FromUint64(1)<> Int32FromInt32(12))) + v6 = bp + 16 + *(*Tuint64_t)(unsafe.Pointer(v6)) = Tuint64_t(*(*Tuint64_t)(unsafe.Pointer(v6)) | Uint64FromUint64(1)<>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint64(1) - q <<= uint32(1) + uxi = uxi << uint64(1) + q = q << uint32(1) goto _8 _8: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint64_t)(unsafe.Pointer(bp + 16)) if i>>int32(63) == uint64(0) { uxi = i - q++ + q = q + 1 } if uxi == uint64(0) { ex = -int32(60) @@ -111278,8 +111278,8 @@ func Xremquo(tls *TLS, x float64, y float64, quo uintptr) (r float64) { goto _9 _9: ; - uxi <<= uint64(1) - ex-- + uxi = uxi << uint64(1) + ex = ex - 1 } } goto end @@ -111287,10 +111287,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi = Tuint64_t(uxi - Uint64FromUint64(1)<>= Uint64FromInt32(-ex + int32(1)) + uxi = uxi >> Uint64FromInt32(-ex+int32(1)) } *(*Tuint64_t)(unsafe.Pointer(bp + 8)) = uxi x = *(*float64)(unsafe.Pointer(bp + 8)) @@ -111298,10 +111298,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float64(Float64FromInt32(2)*x) > y || float64(Float64FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v10 = -Int32FromUint32(q) } else { @@ -111385,13 +111385,13 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _4 _4: ; - ex-- - i <<= uint32(1) + ex = ex - 1 + i = i << uint32(1) } - uxi <<= Uint32FromInt32(-ex + int32(1)) + uxi = uxi << Uint32FromInt32(-ex+int32(1)) } else { - uxi &= -Uint32FromUint32(1) >> Int32FromInt32(9) - uxi |= Uint32FromUint32(1) << Int32FromInt32(23) + uxi = uxi & (-Uint32FromUint32(1) >> Int32FromInt32(9)) + uxi = uxi | Uint32FromUint32(1)<>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } - uxi <<= uint32(1) - q <<= uint32(1) + uxi = uxi << uint32(1) + q = q << uint32(1) goto _6 _6: ; - ex-- + ex = ex - 1 } i = uxi - *(*Tuint32_t)(unsafe.Pointer(bp + 8)) if i>>int32(31) == uint32(0) { uxi = i - q++ + q = q + 1 } if uxi == uint32(0) { ex = -int32(30) @@ -111449,8 +111449,8 @@ func Xremquof(tls *TLS, x float32, y float32, quo uintptr) (r float32) { goto _7 _7: ; - uxi <<= uint32(1) - ex-- + uxi = uxi << uint32(1) + ex = ex - 1 } } goto end @@ -111458,10 +111458,10 @@ end: ; /* scale result and decide between |x| and |x|-|y| */ if ex > 0 { - uxi -= Uint32FromUint32(1) << Int32FromInt32(23) - uxi |= Uint32FromInt32(ex) << int32(23) + uxi = uxi - Uint32FromUint32(1)<>= Uint32FromInt32(-ex + int32(1)) + uxi = uxi >> Uint32FromInt32(-ex+int32(1)) } *(*Tuint32_t)(unsafe.Pointer(bp + 4)) = uxi x = *(*float32)(unsafe.Pointer(bp + 4)) @@ -111469,10 +111469,10 @@ end: y = -y } if ex == ey || ex+int32(1) == ey && (float32(Float32FromInt32(2)*x) > y || float32(Float32FromInt32(2)*x) == y && q%uint32(2) != 0) { - x -= y - q++ + x = x - y + q = q + 1 } - q &= uint32(0x7fffffff) + q = q & uint32(0x7fffffff) if sx^sy != 0 { v8 = -Int32FromUint32(q) } else { @@ -111747,13 +111747,13 @@ func Xscalb(tls *TLS, x float64, fn float64) (r float64) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint64 + var v1, v3 uint64 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float64)(unsafe.Pointer(bp)) = x v1 = *(*uint64)(unsafe.Pointer(bp)) goto _2 @@ -111769,10 +111769,10 @@ _2: return float64(x * fn) } *(*float64)(unsafe.Pointer(bp)) = fn - v6 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)< float64(0) { return float64(x * fn) } else { @@ -111798,13 +111798,13 @@ func Xscalbf(tls *TLS, x float32, fn float32) (r float32) { } bp := tls.Alloc(16) defer tls.Free(16) - var v1, v3, v6 uint32 + var v1, v3 uint32 var v5 bool var _ /* __u at bp+0 */ struct { F__i [0]uint32 F__f float32 } - _, _, _, _ = v1, v3, v5, v6 + _, _, _ = v1, v3, v5 *(*float32)(unsafe.Pointer(bp)) = x v1 = *(*uint32)(unsafe.Pointer(bp)) goto _2 @@ -111820,10 +111820,10 @@ _2: return float32(x * fn) } *(*float32)(unsafe.Pointer(bp)) = fn - v6 = *(*uint32)(unsafe.Pointer(bp)) + v1 = *(*uint32)(unsafe.Pointer(bp)) goto _7 _7: - if !(BoolInt32(v6&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { + if !(BoolInt32(v1&Uint32FromInt32(0x7fffffff) < Uint32FromInt32(0x7f800000)) != 0) { if fn > Float32FromFloat32(0) { return float32(x * fn) } else { @@ -111895,11 +111895,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { _ = y y = x if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { - y *= float64(8.98846567431158e+307) - n -= int32(1023) + y = y * float64(8.98846567431158e+307) + n = n - int32(1023) if n > int32(1023) { n = int32(1023) } @@ -111908,11 +111908,11 @@ func Xscalbn(tls *TLS, x float64, n int32) (r float64) { if n < -int32(1022) { /* make sure final n < -53 to avoid double rounding in the subnormal range */ - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { - y *= Tdouble_t(Float64FromFloat64(2.2250738585072014e-308) * Float64FromFloat64(9.007199254740992e+15)) - n += Int32FromInt32(1022) - Int32FromInt32(53) + y = y * Tdouble_t(Float64FromFloat64(2.2250738585072014e-308)*Float64FromFloat64(9.007199254740992e+15)) + n = n + (Int32FromInt32(1022) - Int32FromInt32(53)) if n < -int32(1022) { n = -int32(1022) } @@ -111939,22 +111939,22 @@ func Xscalbnf(tls *TLS, x float32, n int32) (r float32) { _ = y y = float64(x) if n > int32(127) { - y *= Float64FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float64FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { - y *= Float64FromFloat32(1.7014118346046923e+38) - n -= int32(127) + y = y * Float64FromFloat32(1.7014118346046923e+38) + n = n - int32(127) if n > int32(127) { n = int32(127) } } } else { if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { - y *= Tfloat_t(Float32FromFloat32(1.1754943508222875e-38) * Float32FromFloat32(1.6777216e+07)) - n += Int32FromInt32(126) - Int32FromInt32(24) + y = y * Tfloat_t(Float32FromFloat32(1.1754943508222875e-38)*Float32FromFloat32(1.6777216e+07)) + n = n + (Int32FromInt32(126) - Int32FromInt32(24)) if n < -int32(126) { n = -int32(126) } @@ -112000,12 +112000,12 @@ func Xsin(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 /* High word of x. */ ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e500000) { /* |x| < 2**-26 */ @@ -112020,18 +112020,18 @@ func Xsin(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112063,14 +112063,14 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } bp := tls.Alloc(16) defer tls.Free(16) - var c, s, y1, y2, v1, v2, v3, v4 float64 + var c, s, y1, y2, v1 float64 var ix Tuint32_t var n uint32 var y float32 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1, v2, v3, v4 + _, _, _, _, _, _, _, _ = c, ix, n, s, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { /* if |x| < 2**-27 * sqrt(2) */ @@ -112086,18 +112086,18 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } *(*float64)(unsafe.Pointer(sin)) = x3 @@ -112110,9 +112110,9 @@ func Xsincos(tls *TLS, x3 float64, sin uintptr, cos uintptr) { } /* sincos(Inf or NaN) is NaN */ if ix >= uint32(0x7ff00000) { - v4 = x3 - x3 - *(*float64)(unsafe.Pointer(cos)) = v4 - *(*float64)(unsafe.Pointer(sin)) = v4 + v1 = x3 - x3 + *(*float64)(unsafe.Pointer(cos)) = v1 + *(*float64)(unsafe.Pointer(sin)) = v1 return } /* argument reduction needed */ @@ -112158,13 +112158,13 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { var c, s Tfloat_t var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3, v8 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = c, ix, n, s, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~<= pi/4 */ if ix <= uint32(0x3f490fda) { /* |x| < 2**-12 */ @@ -112180,18 +112180,18 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00100000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } *(*float32)(unsafe.Pointer(sin)) = x3 @@ -112222,11 +112222,11 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { } *(*float32)(unsafe.Pointer(sin)) = -X__sindf(tls, v4) if sign != 0 { - v5 = float64(x3) + _s2pio2 + v4 = float64(x3) + _s2pio2 } else { - v5 = float64(x3) - _s2pio2 + v4 = float64(x3) - _s2pio2 } - *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v5) + *(*float32)(unsafe.Pointer(cos)) = -X__cosdf(tls, v4) return } /* |x| ~<= 9*pi/4 */ @@ -112242,24 +112242,24 @@ func Xsincosf(tls *TLS, x3 float32, sin uintptr, cos uintptr) { return } if sign != 0 { - v6 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v6 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v6) + *(*float32)(unsafe.Pointer(sin)) = X__sindf(tls, v4) if sign != 0 { - v7 = float64(x3) + _s4pio2 + v4 = float64(x3) + _s4pio2 } else { - v7 = float64(x3) - _s4pio2 + v4 = float64(x3) - _s4pio2 } - *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v7) + *(*float32)(unsafe.Pointer(cos)) = X__cosdf(tls, v4) return } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { - v8 = x3 - x3 - *(*float32)(unsafe.Pointer(cos)) = v8 - *(*float32)(unsafe.Pointer(sin)) = v8 + v1 = x3 - x3 + *(*float32)(unsafe.Pointer(cos)) = v1 + *(*float32)(unsafe.Pointer(sin)) = v1 return } /* general argument reduction needed */ @@ -112320,13 +112320,13 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign int32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = Int32FromUint32(ix >> int32(31)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112340,18 +112340,18 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112382,11 +112382,11 @@ func Xsinf(tls *TLS, x3 float32) (r float32) { } } if sign != 0 { - v5 = float64(x3) + _s4pio21 + v4 = float64(x3) + _s4pio21 } else { - v5 = float64(x3) - _s4pio21 + v4 = float64(x3) - _s4pio21 } - return X__sindf(tls, v5) + return X__sindf(tls, v4) } /* sin(Inf or NaN) is NaN */ if ix >= uint32(0x7f800000) { @@ -112556,9 +112556,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { } var d, d0, d1, d2, i, ix, m, r, s, tiny, top, u Tuint64_t var even int32 - var t, y, y1, v1, v3 float64 + var t, y, y1, v1 float64 var v2 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2, v3 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, i, ix, m, r, s, t, tiny, top, u, y, y1, v1, v2 /* special case handling. */ ix = *(*Tuint64_t)(unsafe.Pointer(&x1)) top = ix >> int32(52) @@ -112577,7 +112577,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { v1 = float64(x1 * float64(4.503599627370496e+15)) ix = *(*Tuint64_t)(unsafe.Pointer(&v1)) top = ix >> int32(52) - top -= uint64(52) + top = top - uint64(52) } /* argument reduction: x = 4^e m; with integer e, and m in [1, 4) @@ -112586,7 +112586,7 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { even = Int32FromUint64(top & uint64(1)) m = ix<>= uint64(1) + m = m >> uint64(1) } top = (top + uint64(0x3ff)) >> int32(1) i = ix >> Int32FromInt32(46) % uint64(128) @@ -112614,9 +112614,9 @@ func Xsqrt(tls *TLS, x1 float64) (r1 float64) { d0 = m<> int32(63) - s &= uint64(0x000fffffffffffff) - s |= top << int32(52) + s = s + d1>>int32(63) + s = s & uint64(0x000fffffffffffff) + s = s | top< %v", r1) }() } var d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, tiny, u Tuint32_t - var t, y, y1, v1, v4 float32 + var t, y, y1, v1 float32 var v2 uint32 var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3, v4 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, d0, d1, d2, even, ey, i, ix, m, m0, m1, r, s, t, tiny, u, y, y1, v1, v2, v3 ix = *(*Tuint32_t)(unsafe.Pointer(&x1)) if ix-uint32(0x00800000) >= Uint32FromInt32(Int32FromInt32(0x7f800000)-Int32FromInt32(0x00800000)) { /* x < 0x1p-126 or inf or nan. */ @@ -112726,7 +112726,7 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { /* x is subnormal, normalize it. */ v1 = float32(x1 * Float32FromFloat32(8.388608e+06)) ix = *(*Tuint32_t)(unsafe.Pointer(&v1)) - ix -= Uint32FromInt32(Int32FromInt32(23) << Int32FromInt32(23)) + ix = ix - Uint32FromInt32(Int32FromInt32(23)<> int32(1) - ey += Uint32FromInt32(Int32FromInt32(0x3f800000) >> Int32FromInt32(1)) - ey &= uint32(0x7f800000) + ey = ey + Uint32FromInt32(Int32FromInt32(0x3f800000)>>Int32FromInt32(1)) + ey = ey & uint32(0x7f800000) i = ix >> Int32FromInt32(17) % uint32(128) r = uint32(X__rsqrt_tab[i]) << int32(16) /* |r*sqrt(m) - 1| < 0x1p-8 */ @@ -112761,9 +112761,9 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { d0 = m<> int32(31) - s &= uint32(0x007fffff) - s |= ey + s = s + d1>>int32(31) + s = s & uint32(0x007fffff) + s = s | ey y1 = *(*float32)(unsafe.Pointer(&s)) if int32(FENV_SUPPORT) != 0 { if d2 == uint32(0) { @@ -112773,13 +112773,13 @@ func Xsqrtf(tls *TLS, x1 float32) (r1 float32) { } /* handle rounding and inexact exception. */ tiny = Uint32FromInt32(v3) - tiny |= (d1 ^ d2) & uint32(0x80000000) + tiny = tiny | (d1^d2)&uint32(0x80000000) t = *(*float32)(unsafe.Pointer(&tiny)) y = y1 + t - v4 = y + v1 = y goto _5 _5: - y1 = v4 + y1 = v1 } return y1 } @@ -112805,11 +112805,11 @@ func Xtan(tls *TLS, x3 float64) (r float64) { var ix Tuint32_t var n uint32 var y float32 - var y1, y2, v1, v2, v3 float64 + var y1, y2, v1 float64 var _ /* y at bp+0 */ [2]float64 - _, _, _, _, _, _, _, _ = ix, n, y, y1, y2, v1, v2, v3 + _, _, _, _, _, _ = ix, n, y, y1, y2, v1 ix = uint32(*(*Tuint64_t)(unsafe.Pointer(&x3)) >> int32(32)) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) /* |x| ~< pi/4 */ if ix <= uint32(0x3fe921fb) { if ix < uint32(0x3e400000) { /* |x| < 2**-27 */ @@ -112824,18 +112824,18 @@ func Xtan(tls *TLS, x3 float64) (r float64) { } else { if uint64(8) == uint64(8) { if ix < uint32(0x00100000) { - v2 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y1 = v2 + y1 = v1 } else { if ix < uint32(0x00100000) { - v3 = x3 / Float64FromFloat32(1.329227995784916e+36) + v1 = x3 / Float64FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float64FromFloat32(1.329227995784916e+36) + v1 = x3 + Float64FromFloat32(1.329227995784916e+36) } - y2 = v3 + y2 = v1 } } return x3 @@ -112871,13 +112871,13 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { defer tls.Free(16) var ix Tuint32_t var n, sign uint32 - var y, v1, v2, v3 float32 - var y1, y2, v4, v5, v6, v7 float64 + var y, v1 float32 + var y1, y2, v4 float64 var _ /* y at bp+0 */ float64 - _, _, _, _, _, _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v2, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = ix, n, sign, y, y1, y2, v1, v4 ix = *(*Tuint32_t)(unsafe.Pointer(&x3)) sign = ix >> int32(31) - ix &= uint32(0x7fffffff) + ix = ix & uint32(0x7fffffff) if ix <= uint32(0x3f490fda) { /* |x| ~<= pi/4 */ if ix < uint32(0x39800000) { /* |x| < 2**-12 */ /* raise inexact if x!=0 and underflow if subnormal */ @@ -112891,18 +112891,18 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { } else { if uint64(4) == uint64(8) { if ix < uint32(0x00800000) { - v2 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v2 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y1 = float64(v2) + y1 = float64(v1) } else { if ix < uint32(0x00800000) { - v3 = x3 / Float32FromFloat32(1.329227995784916e+36) + v1 = x3 / Float32FromFloat32(1.329227995784916e+36) } else { - v3 = x3 + Float32FromFloat32(1.329227995784916e+36) + v1 = x3 + Float32FromFloat32(1.329227995784916e+36) } - y2 = float64(v3) + y2 = float64(v1) } } return x3 @@ -112919,28 +112919,28 @@ func Xtanf(tls *TLS, x3 float32) (r float32) { return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v5 = float64(x3) + _t2pio2 + v4 = float64(x3) + _t2pio2 } else { - v5 = float64(x3) - _t2pio2 + v4 = float64(x3) - _t2pio2 } - return X__tandf(tls, v5, 0) + return X__tandf(tls, v4, 0) } } if ix <= uint32(0x40e231d5) { /* |x| ~<= 9*pi/4 */ if ix <= uint32(0x40afeddf) { /* |x| ~<= 7*pi/4 */ if sign != 0 { - v6 = float64(x3) + _t3pio2 + v4 = float64(x3) + _t3pio2 } else { - v6 = float64(x3) - _t3pio2 + v4 = float64(x3) - _t3pio2 } - return X__tandf(tls, v6, int32(1)) + return X__tandf(tls, v4, int32(1)) } else { if sign != 0 { - v7 = float64(x3) + _t4pio2 + v4 = float64(x3) + _t4pio2 } else { - v7 = float64(x3) - _t4pio2 + v4 = float64(x3) - _t4pio2 } - return X__tandf(tls, v7, 0) + return X__tandf(tls, v4, 0) } } /* tan(Inf or NaN) is NaN */ @@ -113138,8 +113138,8 @@ func _sinpi(tls *TLS, x float64) (r float64) { /* reduce x into [-.25,.25] */ n = int32(Float64FromInt32(4) * x) n = (n + int32(1)) / int32(2) - x -= float64(float64(n) * float64(0.5)) - x *= _pi4 + x = x - float64(float64(n)*float64(0.5)) + x = x * _pi4 switch n { default: /* case 4 */ fallthrough @@ -113239,7 +113239,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _1 _1: ; - i-- + i = i - 1 } } else { i = 0 @@ -113252,7 +113252,7 @@ func _S(tls *TLS, x float64) (r float64) { goto _2 _2: ; - i++ + i = i + 1 } } return num / den @@ -113322,7 +113322,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { } return -Float64FromFloat64(0) } - x3 *= float64(8.98846567431158e+307) + x3 = x3 * float64(8.98846567431158e+307) return x3 } if sign != 0 { @@ -113335,10 +113335,10 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { y3 = absx + _gmhalf if absx > _gmhalf { dy = y3 - absx - dy -= _gmhalf + dy = dy - _gmhalf } else { dy = y3 - _gmhalf - dy -= absx + dy = dy - absx } z = absx - float64(0.5) r = Tdouble_t(_S(tls, absx) * Xexp(tls, -y3)) @@ -113349,7 +113349,7 @@ func Xtgamma(tls *TLS, x3 float64) (r1 float64) { dy = -dy z = -z } - r += Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r) / y3 + r = r + Tdouble_t(Tdouble_t(dy*(_gmhalf+Float64FromFloat64(0.5)))*r)/y3 z = Xpow(tls, y3, float64(float64(0.5)*z)) y3 = float64(Tdouble_t(r*z) * z) return y3 @@ -113496,12 +113496,12 @@ func Xa64l(tls *TLS, s uintptr) (r int64) { if !(d != 0) { break } - x |= Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits)))) << e + x = x | Uint32FromInt64(int64(d)-t__predefined_ptrdiff_t(uintptr(unsafe.Pointer(&_digits))))<>= uint32(6) + p = p + 1 + x = x >> uint32(6) } *(*uint8)(unsafe.Pointer(p)) = uint8(0) return uintptr(unsafe.Pointer(&_s)) @@ -113552,7 +113552,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(i != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i-uint64(1))))) != int32('/')) { @@ -113561,7 +113561,7 @@ func Xbasename(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } return s + uintptr(i) } @@ -113595,7 +113595,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) != int32('/')) { @@ -113607,7 +113607,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _2 _2: ; - i-- + i = i - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(i)))) == int32('/')) { @@ -113619,7 +113619,7 @@ func Xdirname(tls *TLS, s uintptr) (r uintptr) { goto _3 _3: ; - i-- + i = i - 1 } *(*uint8)(unsafe.Pointer(s + uintptr(i+uint64(1)))) = uint8(0) return s @@ -113713,7 +113713,7 @@ func __strcolcmp(tls *TLS, lstr uintptr, bstr uintptr) (r int32) { _ = i i = uint64(0) for *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 && *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(lstr + uintptr(i)))) { - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(lstr + uintptr(i))) != 0 || *(*uint8)(unsafe.Pointer(bstr + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bstr + uintptr(i)))) != int32(':') { return int32(1) @@ -113728,11 +113728,11 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text } bp := tls.Alloc(80) defer tls.Free(80) - var cmsg, errstring, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 uintptr + var cmsg, errstring, v1, v2, v3, v4, v5, v6, v7, v8 uintptr var consolefd, i, ret, verb int32 var msgs [6]uintptr var _ /* cs at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v10, v11, v12, v13, v14, v15, v16, v17, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cmsg, consolefd, errstring, i, msgs, ret, verb, v1, v2, v3, v4, v5, v6, v7, v8 ret = 0 verb = 0 errstring = uintptr(MM_NULLSEV) @@ -113825,17 +113825,17 @@ func Xfmtmsg(tls *TLS, classification int64, label uintptr, severity int32, text goto _9 _9: ; - i++ + i = i + 1 } if msgs[i] == UintptrFromInt32(0) { //ignore MSGVERB-unrecognized component verb = int32(0xFF) break } else { - verb |= int32(1) << i + verb = verb | int32(1)< 0 { - i += l + i = i + l } else { - i++ + i = i + 1 } } if *(*Twchar_t)(unsafe.Pointer(bp + 4)) != *(*Twchar_t)(unsafe.Pointer(bp)) || *(*Twchar_t)(unsafe.Pointer(bp)) == int32(':') { @@ -114114,11 +114114,11 @@ func Xgetopt(tls *TLS, argc int32, argv uintptr, optstring uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i)))) == int32(':') { Xoptarg = uintptr(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + uintptr(i+int32(1))))) != int32(':') || X__optpos != 0 { - v3 = Xoptind - Xoptind++ - Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v3)*8)) + v1 = Xoptind + Xoptind = Xoptind + 1 + Xoptarg = *(*uintptr)(unsafe.Pointer(argv + uintptr(v1)*8)) if X__optpos != 0 { - Xoptarg += uintptr(X__optpos) + Xoptarg = Xoptarg + uintptr(X__optpos) } X__optpos = 0 } @@ -114170,7 +114170,7 @@ func _permute(tls *TLS, argv uintptr, dest int32, src int32) { goto _1 _1: ; - i-- + i = i - 1 } *(*uintptr)(unsafe.Pointer(av + uintptr(dest)*8)) = tmp } @@ -114199,7 +114199,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _1 _1: ; - i++ + i = i + 1 } Xoptind = i } @@ -114216,7 +114216,7 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo goto _2 _2: ; - i1++ + i1 = i1 + 1 } Xoptind = skipped + cnt } @@ -114224,9 +114224,9 @@ func ___getopt_long(tls *TLS, argc int32, argv uintptr, optstring uintptr, longo } func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, longopts uintptr, idx uintptr, longonly int32) (r int32) { - var arg, name, opt, start, v5, v6 uintptr + var arg, name, opt, start, v5 uintptr var cnt, colon, i, j, l, match, v2 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5, v6 + _, _, _, _, _, _, _, _, _, _, _, _ = arg, cnt, colon, i, j, l, match, name, opt, start, v2, v5 Xoptarg = uintptr(0) if longopts != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))))) == int32('-') && (longonly != 0 && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) != int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 1))) == int32('-') && *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8)) + 2)) != 0) { colon = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring + BoolUintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(optstring))) == int32('-'))))) == int32(':')) @@ -114241,11 +114241,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, name = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname opt = start if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('-') { - opt++ + opt = opt + 1 } for *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) { - name++ - opt++ + name = name + 1 + opt = opt + 1 } if *(*uint8)(unsafe.Pointer(opt)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) != int32('=') { goto _1 @@ -114256,11 +114256,11 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, cnt = int32(1) break } - cnt++ + cnt = cnt + 1 goto _1 _1: ; - i++ + i = i + 1 } if cnt == int32(1) && longonly != 0 && int64(arg)-int64(start) == int64(Xmblen(tls, start, uint64(MB_LEN_MAX))) { l = int32(int64(arg) - int64(start)) @@ -114277,22 +114277,22 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, goto _4 _4: ; - j++ + j = j + 1 } if j == l { - cnt++ + cnt = cnt + 1 break } goto _3 _3: ; - i++ + i = i + 1 } } if cnt == int32(1) { i = match opt = arg - Xoptind++ + Xoptind = Xoptind + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(opt))) == int32('=') { if !((*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fhas_arg != 0) { Xoptopt = (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fval @@ -114318,7 +114318,7 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), __ccgo_ts+750, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname, Xstrlen(tls, (*(*Toption)(unsafe.Pointer(longopts + uintptr(i)*32))).Fname)) return int32('?') } - Xoptind++ + Xoptind = Xoptind + 1 } } if idx != 0 { @@ -114334,13 +114334,13 @@ func ___getopt_long_core(tls *TLS, argc int32, argv uintptr, optstring uintptr, Xoptopt = 0 if !(colon != 0) && Xopterr != 0 { if cnt != 0 { - v6 = __ccgo_ts + 819 + v5 = __ccgo_ts + 819 } else { - v6 = __ccgo_ts + 726 + v5 = __ccgo_ts + 726 } - X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v6, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) + X__getopt_msg(tls, *(*uintptr)(unsafe.Pointer(argv)), v5, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2), Xstrlen(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(Xoptind)*8))+uintptr(2))) } - Xoptind++ + Xoptind = Xoptind + 1 return int32('?') } } @@ -114401,9 +114401,9 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) var ret int32 - var v1, v2 uint64 + var v1 uint64 var _ /* k_rlim at bp+0 */ [2]uint64 - _, _, _ = ret, v1, v2 + _, _ = ret, v1 ret = int32(X__syscall_ret(tls, Uint64FromInt64(X__syscall4(tls, int64(SYS_prlimit64), int64(Int32FromInt32(0)), int64(resource), int64(Int32FromInt32(0)), int64(rlim))))) if !(ret != 0) { if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { @@ -114426,11 +114426,11 @@ func Xgetrlimit(tls *TLS, resource int32, rlim uintptr) (r int32) { } (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = v1 if (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] == -Uint64FromUint64(1) { - v2 = ^Uint64FromUint64(0) + v1 = ^Uint64FromUint64(0) } else { - v2 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] + v1 = (*(*[2]uint64)(unsafe.Pointer(bp)))[int32(1)] } - (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v2 + (*Trlimit)(unsafe.Pointer(rlim)).Frlim_max = v1 if (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur >= ^Uint64FromUint64(0) { (*Trlimit)(unsafe.Pointer(rlim)).Frlim_cur = ^Uint64FromUint64(0) } @@ -114482,7 +114482,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { if *(*uintptr)(unsafe.Pointer(opt)) != 0 { v2 = opt v1 = *(*uintptr)(unsafe.Pointer(v2)) - *(*uintptr)(unsafe.Pointer(v2))++ + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(opt)) = s + uintptr(Xstrlen(tls, s)) @@ -114507,7 +114507,7 @@ func Xgetsubopt(tls *TLS, opt uintptr, keys uintptr, val uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } return -int32(1) } @@ -114795,15 +114795,15 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di } else { Xmemcpy(tls, new1+uintptr(new_offset), old+uintptr(old_offset), Uint64FromInt32(len1)) } - new_offset += len1 - old_offset += len1 + new_offset = new_offset + len1 + old_offset = old_offset + len1 if (*Tioctl_compat_map)(unsafe.Pointer(map1)).Fforce_align != 0 { v2 = uint64(8) } else { v2 = uint64(UintptrFromInt32(0) + 8) } align = Int32FromUint64(v2) - new_offset += (align - int32(1)) & -new_offset + new_offset = new_offset + (align-int32(1))&-new_offset if dir == int32(W) { Xmemcpy(tls, bp, new1+uintptr(new_offset), uint64(8)) *(*int64)(unsafe.Pointer(bp + 8)) = *(*int64)(unsafe.Pointer(bp)) @@ -114813,12 +114813,12 @@ func _convert_ioctl_struct(tls *TLS, map1 uintptr, old uintptr, new1 uintptr, di *(*int64)(unsafe.Pointer(bp)) = *(*int64)(unsafe.Pointer(bp + 8)) Xmemcpy(tls, new1+uintptr(new_offset), bp, uint64(8)) } - new_offset = int32(uint64(new_offset) + Uint64FromInt64(8)) - old_offset = int32(uint64(old_offset) + Uint64FromInt64(8)) + new_offset = Int32FromUint64(uint64(new_offset) + Uint64FromInt64(8)) + old_offset = Int32FromUint64(uint64(old_offset) + Uint64FromInt64(8)) goto _1 _1: ; - i++ + i = i + 1 } if dir == int32(W) { Xmemcpy(tls, old+uintptr(old_offset), new1+uintptr(new_offset), Uint64FromInt32(old_size-old_offset)) @@ -114866,7 +114866,7 @@ func Xioctl(tls *TLS, fd int32, req int32, va uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } } return int32(X__syscall_ret(tls, Uint64FromInt32(r))) @@ -115009,28 +115009,28 @@ func Xendmntent(tls *TLS, f uintptr) (r int32) { func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { var cval uint8 - var dest, src, val, v1, v2, v3, v4, v6, v7, v8, v9 uintptr + var dest, src, val, v1, v2 uintptr var i int32 - _, _, _, _, _, _, _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2, v3, v4, v6, v7, v8, v9 + _, _, _, _, _, _, _ = cval, dest, i, src, val, v1, v2 dest = beg src = beg for *(*uint8)(unsafe.Pointer(src)) != 0 { cval = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(src))) != int32('\\') { v1 = dest - dest++ + dest = dest + 1 v2 = src - src++ + src = src + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } if Int32FromUint8(*(*uint8)(unsafe.Pointer(src + 1))) == int32('\\') { - src++ - v3 = dest - dest++ - v4 = src - src++ - *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) + src = src + 1 + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) continue } val = src + uintptr(1) @@ -115040,29 +115040,29 @@ func _unescape_ent(tls *TLS, beg uintptr) (r uintptr) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) >= int32('0') && Int32FromUint8(*(*uint8)(unsafe.Pointer(val))) <= int32('7') { - cval = uint8(int32(cval) << Int32FromInt32(3)) - v6 = val - val++ - cval = uint8(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) - Int32FromUint8('0'))) + cval = Uint8FromInt32(int32(cval) << Int32FromInt32(3)) + v1 = val + val = val + 1 + cval = Uint8FromInt32(int32(cval) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) - Int32FromUint8('0'))) } else { break } goto _5 _5: ; - i++ + i = i + 1 } if cval != 0 { - v7 = dest - dest++ - *(*uint8)(unsafe.Pointer(v7)) = cval + v1 = dest + dest = dest + 1 + *(*uint8)(unsafe.Pointer(v1)) = cval src = val } else { - v8 = dest - dest++ - v9 = src - src++ - *(*uint8)(unsafe.Pointer(v8)) = *(*uint8)(unsafe.Pointer(v9)) + v1 = dest + dest = dest + 1 + v2 = src + src = src + 1 + *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } } *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -115111,7 +115111,7 @@ func Xgetmntent_r(tls *TLS, f uintptr, mnt uintptr, linebuf uintptr, buflen int3 goto _1 _1: ; - i++ + i = i + 1 } Xsscanf(tls, linebuf, __ccgo_ts+855, VaList(bp+40, bp, bp+uintptr(1)*4, bp+uintptr(2)*4, bp+uintptr(3)*4, bp+uintptr(4)*4, bp+uintptr(5)*4, bp+uintptr(6)*4, bp+uintptr(7)*4, mnt+32, mnt+36)) } @@ -115169,15 +115169,15 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag bp := tls.Alloc(192) defer tls.Free(192) var d, de, v10 uintptr - var dfd, err, r, type1, v11, v12, v3, v4, v7 int32 + var dfd, err, r, type1, v3 int32 var j, k, l Tsize_t var v1 uint64 - var v13, v8 bool + var v8 bool var v2 Tino_t var _ /* lev at bp+176 */ TFTW var _ /* new at bp+144 */ Thistory var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v11, v12, v13, v2, v3, v4, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, de, dfd, err, j, k, l, r, type1, v1, v10, v2, v3, v8 l = Xstrlen(tls, path) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(l-uint64(1))))) == int32('/') { v1 = l - uint64(1) @@ -115229,11 +115229,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag (*(*Thistory)(unsafe.Pointer(bp + 144))).Fdev = (*(*Tstat)(unsafe.Pointer(bp))).Fst_dev (*(*Thistory)(unsafe.Pointer(bp + 144))).Fino = (*(*Tstat)(unsafe.Pointer(bp))).Fst_ino if h != 0 { - v4 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) + v3 = (*Thistory)(unsafe.Pointer(h)).Flevel + int32(1) } else { - v4 = 0 + v3 = 0 } - (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v4 + (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel = v3 (*(*Thistory)(unsafe.Pointer(bp + 144))).Fbase = Int32FromUint64(j + uint64(1)) (*(*TFTW)(unsafe.Pointer(bp + 176))).Flevel = (*(*Thistory)(unsafe.Pointer(bp + 144))).Flevel if h != 0 { @@ -115247,7 +115247,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _5 _5: ; - k-- + k = k - 1 } for { if !(k != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(path + uintptr(k-uint64(1))))) != int32('/')) { @@ -115256,7 +115256,7 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag goto _6 _6: ; - k-- + k = k - 1 } (*(*TFTW)(unsafe.Pointer(bp + 176))).Fbase = Int32FromUint64(k) } @@ -115271,10 +115271,10 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } if v8 = !(flags&Int32FromInt32(FTW_DEPTH) != 0); v8 { - v7 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v7 + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v8 && v7 != 0 { + if v8 && v3 != 0 { return r } for { @@ -115312,9 +115312,9 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } *(*uint8)(unsafe.Pointer(path + uintptr(j))) = uint8('/') Xstrcpy(tls, path+uintptr(j)+uintptr(1), de+19) - v11 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) - r = v11 - if v11 != 0 { + v3 = _do_nftw(tls, path, __ccgo_fp_fn, fd_limit-int32(1), flags, bp+144) + r = v3 + if v3 != 0 { Xclosedir(tls, d) return r } @@ -115326,11 +115326,11 @@ func _do_nftw(tls *TLS, path uintptr, __ccgo_fp_fn uintptr, fd_limit int32, flag } } *(*uint8)(unsafe.Pointer(path + uintptr(l))) = uint8(0) - if v13 = flags&int32(FTW_DEPTH) != 0; v13 { - v12 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) - r = v12 + if v8 = flags&int32(FTW_DEPTH) != 0; v8 { + v3 = (*(*func(*TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_fn})))(tls, path, bp, type1, bp+176) + r = v3 } - if v13 && v12 != 0 { + if v8 && v3 != 0 { return r } return 0 @@ -115503,7 +115503,7 @@ func _slash_len(tls *TLS, s uintptr) (r Tsize_t) { _ = s0 s0 = s for Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('/') { - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(s0)) } @@ -115516,12 +115516,12 @@ func Xrealpath(tls *TLS, filename uintptr, resolved uintptr) (r uintptr) { bp := tls.Alloc(8208) defer tls.Free(8208) var check_dir, up int32 - var cnt, l, l0, nup, p, q, v10, v11, v4, v5, v6, v7, v9 Tsize_t + var cnt, l, l0, nup, p, q, v4 Tsize_t var k Tssize_t var z uintptr var _ /* output at bp+4097 */ [4096]uint8 var _ /* stack at bp+0 */ [4097]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v10, v11, v4, v5, v6, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = check_dir, cnt, k, l, l0, nup, p, q, up, z, v4 cnt = uint64(0) nup = uint64(0) check_dir = 0 @@ -115556,27 +115556,27 @@ _3: nup = uint64(0) q = uint64(0) v4 = q - q++ + q = q + 1 (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') - p++ + p = p + 1 /* Initial // is special. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p+uint64(1)]) != int32('/') { - v5 = q - q++ - (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v5] = uint8('/') + v4 = q + q = q + 1 + (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[v4] = uint8('/') } goto _2 } z = X__strchrnul(tls, bp+uintptr(p), int32('/')) - v6 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) - l = v6 - l0 = v6 + v4 = Uint64FromInt64(int64(z) - int64(bp+uintptr(p))) + l = v4 + l0 = v4 if !(l != 0) && !(check_dir != 0) { goto _1 } /* Skip any . component but preserve check_dir status. */ if l == uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('.') { - p += l + p = p + l goto _2 } /* Copy next component onto output at least temporarily, to @@ -115586,17 +115586,17 @@ _3: if !(p != 0) { goto toolong } - p-- - v7 = p - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v7] = uint8('/') - l++ + p = p - 1 + v4 = p + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') + l = l + 1 } if q+l >= uint64(PATH_MAX) { goto toolong } Xmemcpy(tls, bp+4097+uintptr(q), bp+uintptr(p), l) (*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q+l] = uint8(0) - p += l + p = p + l up = 0 if l0 == uint64(2) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(2)]) == int32('.') && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p-uint64(1)]) == int32('.') { up = int32(1) @@ -115605,8 +115605,8 @@ _3: * if there are none, accumulate .. components to * later apply to cwd, if needed. */ if q <= uint64(3)*nup { - nup++ - q += l + nup = nup + 1 + q = q + l goto _2 } /* When previous components are already known to be @@ -115635,23 +115635,23 @@ skip_readlink: check_dir = 0 if up != 0 { for q != 0 && Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[q-uint64(1)]) != int32('/') { - q-- + q = q - 1 } if q > uint64(1) && (q > uint64(2) || Int32FromUint8((*(*[4096]uint8)(unsafe.Pointer(bp + 4097)))[0]) != int32('/')) { - q-- + q = q - 1 } goto _2 } if l0 != 0 { - q += l + q = q + l } check_dir = Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) goto _2 _8: ; - cnt++ - v9 = cnt - if v9 == uint64(SYMLOOP_MAX) { + cnt = cnt + 1 + v4 = cnt + if v4 == uint64(SYMLOOP_MAX) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(ELOOP) return uintptr(0) } @@ -115659,10 +115659,10 @@ _8: * stack to avoid /->// or //->/// or spurious toolong. */ if Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[k-int64(1)]) == int32('/') { for Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[p]) == int32('/') { - p++ + p = p + 1 } } - p -= Uint64FromInt64(k) + p = p - Uint64FromInt64(k) Xmemmove(tls, bp+uintptr(p), bp, Uint64FromInt64(k)) /* Skip the stack advancement in case we have a new * absolute base path. */ @@ -115670,7 +115670,7 @@ _8: goto _2 _2: ; - p += _slash_len(tls, bp+uintptr(p)) + p = p + _slash_len(tls, bp+uintptr(p)) goto _3 goto _1 _1: @@ -115684,26 +115684,26 @@ _1: /* Cancel any initial .. components. */ p = uint64(0) for { - v10 = nup - nup-- - if !(v10 != 0) { + v4 = nup + nup = nup - 1 + if !(v4 != 0) { break } for l > uint64(1) && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - l-- + l = l - 1 } if l > uint64(1) { - l-- + l = l - 1 } - p += uint64(2) + p = p + uint64(2) if p < q { - p++ + p = p + 1 } } if q-p != 0 && Int32FromUint8((*(*[4097]uint8)(unsafe.Pointer(bp)))[l-uint64(1)]) != int32('/') { - v11 = l - l++ - (*(*[4097]uint8)(unsafe.Pointer(bp)))[v11] = uint8('/') + v4 = l + l = l + 1 + (*(*[4097]uint8)(unsafe.Pointer(bp)))[v4] = uint8('/') } if l+(q-p)+uint64(1) >= uint64(PATH_MAX) { goto toolong @@ -116227,19 +116227,19 @@ func _is_lost_conn(tls *TLS, e int32) (r int32) { func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { bp := tls.Alloc(1184) defer tls.Free(1184) - var errno_save, fd, l, l2, pid, v1, v2 int32 + var errno_save, fd, l, l2, pid, v1 int32 var _ /* buf at bp+80 */ [1024]uint8 var _ /* hlen at bp+1104 */ int32 var _ /* now at bp+16 */ Ttime_t var _ /* timebuf at bp+0 */ [16]uint8 var _ /* tm at bp+24 */ Ttm - _, _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1, v2 + _, _, _, _, _, _ = errno_save, fd, l, l2, pid, v1 errno_save = *(*int32)(unsafe.Pointer(X__errno_location(tls))) if _log_fd < 0 { ___openlog(tls) } if !(priority&Int32FromInt32(LOG_FACMASK) != 0) { - priority |= _log_facility + priority = priority | _log_facility } *(*Ttime_t)(unsafe.Pointer(bp + 16)) = Xtime(tls, UintptrFromInt32(0)) Xgmtime_r(tls, bp+16, bp+24) @@ -116257,12 +116257,12 @@ func __vsyslog(tls *TLS, priority int32, message uintptr, ap Tva_list) { if Uint64FromInt32(l2) >= uint64(1024)-Uint64FromInt32(l) { l = Int32FromUint64(Uint64FromInt64(1024) - Uint64FromInt32(1)) } else { - l += l2 + l = l + l2 } if Int32FromUint8((*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[l-int32(1)]) != int32('\n') { - v2 = l - l++ - (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v2] = uint8('\n') + v1 = l + l = l + 1 + (*(*[1024]uint8)(unsafe.Pointer(bp + 80)))[v1] = uint8('\n') } if Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0 && (!(_is_lost_conn(tls, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0) || Xconnect(tls, _log_fd, uintptr(unsafe.Pointer(&_log_addr)), uint32(12)) < 0 || Xsend(tls, _log_fd, bp+80, Uint64FromInt32(l), 0) < 0) && _log_opt&int32(LOG_CONS) != 0 { fd = Xopen(tls, __ccgo_ts+679, Int32FromInt32(O_WRONLY)|Int32FromInt32(O_NOCTTY)|Int32FromInt32(O_CLOEXEC), 0) @@ -116481,7 +116481,7 @@ func X__shm_mapname(tls *TLS, name uintptr, buf uintptr) (r uintptr) { var p, v1 uintptr _, _ = p, v1 for Int32FromUint8(*(*uint8)(unsafe.Pointer(name))) == int32('/') { - name++ + name = name + 1 } v1 = X__strchrnul(tls, name, int32('/')) p = v1 @@ -116726,11 +116726,11 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize defer tls.Free(16) var N Tsize_t var c uint32 - var s, v3, v4 uintptr + var s, v3 uintptr var v1 Twchar_t var v2 int32 var _ /* dummy at bp+0 */ Twchar_t - _, _, _, _, _, _, _ = N, c, s, v1, v2, v3, v4 + _, _, _, _, _, _ = N, c, s, v1, v2, v3 s = src N = n if !(st != 0) { @@ -116769,9 +116769,9 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto ilseq } v3 = s - s++ + s = s + 1 c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v3)))-uint32(0xc2)] - n-- + n = n - 1 } if n != 0 { if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { @@ -116780,10 +116780,10 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n Tsize_t, st uintptr) (r Tsize goto loop loop: ; - v4 = s - s++ - c = c< %v", r) }() } var c, v1 uint32 - var s, v12, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v5, v6 uintptr + var s, v5, v6 uintptr var wn0 Tsize_t var v2 bool var v3 int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, s, wn0, v1, v12, v16, v17, v18, v19, v2, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v3, v30, v5, v6 + _, _, _, _, _, _, _, _ = c, s, wn0, v1, v2, v3, v5, v6 s = *(*uintptr)(unsafe.Pointer(src)) wn0 = wn c = uint32(0) @@ -116945,12 +116945,12 @@ func Xmbsrtowcs(tls *TLS, ws uintptr, src uintptr, wn Tsize_t, st uintptr) (r Ts break } v5 = s - s++ + s = s + 1 c = uint32(*(*uint8)(unsafe.Pointer(v5))) - v6 = ws + v5 = ws ws += 4 - *(*Twchar_t)(unsafe.Pointer(v6)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) - wn-- + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromInt32(0xdfff) & int32(Int8FromUint32(c)) + wn = wn - 1 goto _4 _4: } @@ -116965,44 +116965,44 @@ _11: ; if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - s += uintptr(4) - wn -= uint64(4) + s = s + uintptr(4) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - s++ - wn-- + s = s + 1 + wn = wn - 1 goto _10 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _9 } - v12 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v12)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume0 resume0: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _9 } - s++ + s = s + 1 if c&(Uint32FromUint32(1)<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _9 } - s++ + s = s + 1 } } - wn-- + wn = wn - 1 c = uint32(0) goto _10 _10: @@ -117022,76 +117022,76 @@ _15: } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) && uint64(s)%uint64(4) == uint64(0) { for wn >= uint64(5) && !((*(*uint32)(unsafe.Pointer(s))|(*(*uint32)(unsafe.Pointer(s))-Uint32FromInt32(0x01010101)))&Uint32FromUint32(0x80808080) != 0) { - v16 = ws + v5 = ws ws += 4 - v17 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v16)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v17))) - v18 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v19 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v18)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v19))) - v20 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v21 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v20)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v21))) - v22 = ws + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + v5 = ws ws += 4 - v23 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v22)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v23))) - wn -= uint64(4) + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - uint64(4) } } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(1) < uint32(0x7f) { - v24 = ws + v5 = ws ws += 4 - v25 = s - s++ - *(*Twchar_t)(unsafe.Pointer(v24)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v25))) - wn-- + v6 = s + s = s + 1 + *(*Twchar_t)(unsafe.Pointer(v5)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + wn = wn - 1 goto _14 } if uint32(*(*uint8)(unsafe.Pointer(s)))-uint32(0xc2) > Uint32FromUint32(0xf4)-Uint32FromUint32(0xc2) { goto _13 } - v26 = s - s++ - c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v26)))-uint32(0xc2)] + v5 = s + s = s + 1 + c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(v5)))-uint32(0xc2)] goto resume resume: ; if (Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { - s-- + s = s - 1 goto _13 } - v27 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(2) + s = s - uintptr(2) goto _13 } - v28 = s - s++ - c = c<= uint32(0x40) { - s -= uintptr(3) + s = s - uintptr(3) goto _13 } - v29 = s - s++ - c = c<>int32(3)-int32(0x10)|(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))>>int32(3)+Int32FromUint32(c)>>Int32FromInt32(26))) & ^Int32FromInt32(7) != 0 { goto ilseq } - v4 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v5 = s - s++ - c = c<= uint32(0x40) { goto ilseq } - v6 = s - s++ - *(*Twchar_t)(unsafe.Pointer(wc)) = Int32FromUint32(c< %v", r) }() } var v1 int32 - var v2, v3, v4, v5, v6, v7 uintptr - _, _, _, _, _, _, _ = v1, v2, v3, v4, v5, v6, v7 + var v2 uintptr + _, _ = v1, v2 if !(s != 0) { return uint64(1) } @@ -117240,31 +117240,31 @@ func Xwcrtomb(tls *TLS, s uintptr, wc Twchar_t, st uintptr) (r Tsize_t) { } else { if Uint32FromInt32(wc) < uint32(0x800) { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xc0) | wc>>Int32FromInt32(6)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(2) } else { if Uint32FromInt32(wc) < uint32(0xd800) || Uint32FromInt32(wc)-uint32(0xe000) < uint32(0x2000) { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xe0) | wc>>Int32FromInt32(12)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(3) } else { if Uint32FromInt32(wc)-uint32(0x10000) < uint32(0x100000) { - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0xf0) | wc>>Int32FromInt32(18)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(12)&int32(0x3f)) + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(int32(0x80) | wc>>Int32FromInt32(6)&int32(0x3f)) *(*uint8)(unsafe.Pointer(s)) = Uint8FromInt32(int32(0x80) | wc&int32(0x3f)) return uint64(4) } @@ -117310,16 +117310,16 @@ func Xwcsnrtombs(tls *TLS, dst uintptr, wcs uintptr, wn Tsize_t, n Tsize_t, st u } Xmemcpy(tls, dst, bp, l) } - dst += uintptr(l) - n -= l + dst = dst + uintptr(l) + n = n - l } if !(*(*Twchar_t)(unsafe.Pointer(ws)) != 0) { ws = uintptr(0) break } ws += 4 - wn-- - cnt += l + wn = wn - 1 + cnt = cnt + l } if dst != 0 { *(*uintptr)(unsafe.Pointer(wcs)) = ws @@ -117335,9 +117335,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize bp := tls.Alloc(16) defer tls.Free(16) var N, l Tsize_t - var ws2, v2, v3 uintptr + var ws2, v2 uintptr var _ /* buf at bp+0 */ [4]uint8 - _, _, _, _, _ = N, l, ws2, v2, v3 + _, _, _, _ = N, l, ws2, v2 N = n if !(s != 0) { n = uint64(0) @@ -117351,9 +117351,9 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - n += l + n = n + l } else { - n++ + n = n + 1 } goto _1 _1: @@ -117373,13 +117373,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize if !(l+Uint64FromInt32(1) != 0) { return Uint64FromInt32(-Int32FromInt32(1)) } - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -117398,13 +117398,13 @@ func Xwcsrtombs(tls *TLS, s uintptr, ws uintptr, n Tsize_t, st uintptr) (r Tsize return N - n } Xwcrtomb(tls, s, *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws)))), uintptr(0)) - s += uintptr(l) - n -= l + s = s + uintptr(l) + n = n - l } else { - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) - n-- + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(ws))))) + n = n - 1 } *(*uintptr)(unsafe.Pointer(ws)) += 4 } @@ -118615,9 +118615,9 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { return 0 } v2 = i - i++ + i = i + 1 *(*int16)(unsafe.Pointer(offs + uintptr(v2)*2)) = int16(int64(s) - int64(base)) - s += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + int32(1)) + s = s + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(s)))+int32(1)) goto _1 _1: } @@ -118628,8 +118628,8 @@ func _getoffs(tls *TLS, offs uintptr, base uintptr, s uintptr) (r int32) { // // /* label lengths of an ascii domain name s */ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { - var i, j, k, v3, v4 int32 - _, _, _, _, _ = i, j, k, v3, v4 + var i, j, k, v3 int32 + _, _, _, _ = i, j, k, v3 i = 0 j = 0 k = 0 @@ -118641,20 +118641,20 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-k)-uint32(1) > uint32(62) { return 0 } v3 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(lens + uintptr(v3))) = Uint8FromInt32(j - k) if j == l { return i } - j++ - v4 = j - k = v4 + j = j + 1 + v3 = j + k = v3 goto _1 _1: } @@ -118667,34 +118667,34 @@ func _getlens(tls *TLS, lens uintptr, s uintptr, l int32) (r int32) { func _match(tls *TLS, offset uintptr, base uintptr, dn uintptr, end uintptr, lens uintptr, nlen int32) (r int32) { bp := tls.Alloc(256) defer tls.Free(256) - var l, m, noff, o, v2, v3 int32 + var l, m, noff, o, v2 int32 var _ /* offs at bp+0 */ [128]int16 - _, _, _, _, _, _ = l, m, noff, o, v2, v3 + _, _, _, _, _ = l, m, noff, o, v2 m = 0 noff = _getoffs(tls, bp, base, dn) if !(noff != 0) { return 0 } for { - nlen-- + nlen = nlen - 1 v2 = nlen l = Int32FromUint8(*(*uint8)(unsafe.Pointer(lens + uintptr(v2)))) - noff-- - v3 = noff - o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v3]) - end -= uintptr(l) + noff = noff - 1 + v2 = noff + o = int32((*(*[128]int16)(unsafe.Pointer(bp)))[v2]) + end = end - uintptr(l) if l != Int32FromUint8(*(*uint8)(unsafe.Pointer(base + uintptr(o)))) || Xmemcmp(tls, base+uintptr(o)+uintptr(1), end, Uint64FromInt32(l)) != 0 { return m } *(*int32)(unsafe.Pointer(offset)) = o - m += l + m = m + l if nlen != 0 { - m++ + m = m + 1 } if !(nlen != 0) || !(noff != 0) { return m } - end-- + end = end - 1 goto _1 _1: } @@ -118708,17 +118708,17 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l } bp := tls.Alloc(144) defer tls.Free(144) - var bestlen, bestoff, i, j, m, n, v3, v4, v5, v6, v7 int32 + var bestlen, bestoff, i, j, m, n, v3 int32 var end, p, v8 uintptr var l Tsize_t var _ /* lens at bp+4 */ [127]uint8 var _ /* offset at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _ = bestlen, bestoff, end, i, j, l, m, n, p, v3, v8 m = 0 bestlen = 0 l = Xstrnlen(tls, src, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(src + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l > uint64(253) || space <= 0 { return -int32(1) @@ -118769,22 +118769,22 @@ func Xdn_comp(tls *TLS, src uintptr, dst uintptr, space int32, dnptrs uintptr, l goto _2 _2: ; - v4 = j - j++ - i += Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v4]) + int32(1) + v3 = j + j = j + 1 + i = i + (Int32FromUint8((*(*[127]uint8)(unsafe.Pointer(bp + 4)))[v3]) + int32(1)) } /* add tail */ if bestlen != 0 { - v5 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v5))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) - v6 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v6))) = Uint8FromInt32(bestoff) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(int32(0xc0) | bestoff>>int32(8)) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = Uint8FromInt32(bestoff) } else { - v7 = i - i++ - *(*uint8)(unsafe.Pointer(dst + uintptr(v7))) = uint8(0) + v3 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(dst + uintptr(v3))) = uint8(0) } /* save dst pointer */ if i > int32(2) && lastdnptr != 0 && dnptrs != 0 && *(*uintptr)(unsafe.Pointer(dnptrs)) != 0 { @@ -118806,9 +118806,9 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr trc("tls=%v base=%v end=%v src=%v dest=%v space=%v, (%v:)", tls, base, end, src, dest, space, origin(2)) defer func() { trc("-> %v", r) }() } - var dbegin, dend, p, v3, v4, v6, v7 uintptr - var i, j, len1, v1, v5 int32 - _, _, _, _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4, v5, v6, v7 + var dbegin, dend, p, v3, v4 uintptr + var i, j, len1, v1 int32 + _, _, _, _, _, _, _, _, _ = dbegin, dend, i, j, len1, p, v1, v3, v4 p = src dbegin = dest len1 = -int32(1) @@ -118844,26 +118844,26 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr if *(*uint8)(unsafe.Pointer(p)) != 0 { if dest != dbegin { v3 = dest - dest++ + dest = dest + 1 *(*uint8)(unsafe.Pointer(v3)) = uint8('.') } - v4 = p - p++ - j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) + v3 = p + p = p + 1 + j = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) if int64(j) >= int64(end)-int64(p) || int64(j) >= int64(dend)-int64(dest) { return -int32(1) } for { - v5 = j - j-- - if !(v5 != 0) { + v1 = j + j = j - 1 + if !(v1 != 0) { break } - v6 = dest - dest++ - v7 = p - p++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v3 = dest + dest = dest + 1 + v4 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v3)) = *(*uint8)(unsafe.Pointer(v4)) } } else { *(*uint8)(unsafe.Pointer(dest)) = uint8(0) @@ -118876,7 +118876,7 @@ func X__dn_expand(tls *TLS, base uintptr, end uintptr, src uintptr, dest uintptr goto _2 _2: ; - i += int32(2) + i = i + int32(2) } return -int32(1) } @@ -118911,7 +118911,7 @@ func Xdn_skipname(tls *TLS, s uintptr, end uintptr) (r int32) { if int64(end)-int64(p) < int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) { break } else { - p += uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + int32(1)) + p = p + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))+int32(1)) } } } @@ -119021,9 +119021,9 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c trc("tls=%v r=%v rlen=%v __ccgo_fp_callback=%v ctx=%v, (%v:)", tls, r, rlen, __ccgo_fp_callback, ctx, origin(2)) defer func() { trc("-> %v", r1) }() } - var ancount, len1, qdcount, v1, v2 int32 + var ancount, len1, qdcount, v1 int32 var p uintptr - _, _, _, _, _, _ = ancount, len1, p, qdcount, v1, v2 + _, _, _, _, _ = ancount, len1, p, qdcount, v1 if rlen < int32(12) { return -int32(1) } @@ -119035,31 +119035,31 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c ancount = Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 6)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(r + 7))) for { v1 = qdcount - qdcount-- + qdcount = qdcount - 1 if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(6) { return -int32(1) } - p += uintptr(int32(5) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(5)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) } for { - v2 = ancount - ancount-- - if !(v2 != 0) { + v1 = ancount + ancount = ancount - 1 + if !(v1 != 0) { break } for int64(p)-int64(r) < int64(rlen) && uint32(*(*uint8)(unsafe.Pointer(p)))-uint32(1) < uint32(127) { - p++ + p = p + 1 } if p > r+uintptr(rlen)-uintptr(12) { return -int32(1) } - p += uintptr(int32(1) + BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) + p = p + uintptr(int32(1)+BoolInt32(!!(*(*uint8)(unsafe.Pointer(p)) != 0))) len1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8)))*int32(256) + Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 9))) if int64(len1+int32(10)) > int64(r+uintptr(rlen))-int64(p) { return -int32(1) @@ -119067,7 +119067,7 @@ func X__dns_parse(tls *TLS, r uintptr, rlen int32, __ccgo_fp_callback uintptr, c if (*(*func(*TLS, uintptr, int32, uintptr, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_callback})))(tls, ctx, Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))), p+uintptr(10), len1, r, rlen) < 0 { return -int32(1) } - p += uintptr(int32(10) + len1) + p = p + uintptr(int32(10)+len1) } return 0 } @@ -119409,7 +119409,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != int32(':') { return uintptr(0) } else { - x++ + x = x + 1 } } n = Xstrtoul(tls, x, bp+8, int32(16)) @@ -119421,7 +119421,7 @@ func Xether_aton_r(tls *TLS, x uintptr, p_a uintptr) (r uintptr) { goto _1 _1: ; - ii++ + ii = ii + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(x))) != 0 { return uintptr(0) @@ -119461,11 +119461,11 @@ func Xether_ntoa_r(tls *TLS, p_a uintptr, x uintptr) (r uintptr) { } else { v2 = __ccgo_ts + 1006 } - x += uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) + x = x + uintptr(Xsprintf(tls, x, v2, VaList(bp+8, Int32FromUint8(*(*Tuint8_t)(unsafe.Pointer(p_a + uintptr(ii))))))) goto _1 _1: ; - ii++ + ii = ii + 1 } return y } @@ -119508,9 +119508,9 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { if __ccgo_strace { trc("tls=%v p=%v, (%v:)", tls, p, origin(2)) } - var b, p2 uintptr + var b, v2 uintptr var cnt Tsize_t - _, _, _ = b, cnt, p2 + _, _, _ = b, cnt, v2 cnt = uint64(1) for { if !((*Taddrinfo)(unsafe.Pointer(p)).Fai_next != 0) { @@ -119519,15 +119519,15 @@ func Xfreeaddrinfo(tls *TLS, p uintptr) { goto _1 _1: ; - cnt++ + cnt = cnt + 1 p = (*Taddrinfo)(unsafe.Pointer(p)).Fai_next } b = p - uintptr(uint64(UintptrFromInt32(0))) - b -= uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot) * 88 + b = b - uintptr((*Taibuf)(unsafe.Pointer(b)).Fslot)*88 ___lock(tls, b+76) - p2 = b + 82 - *(*int16)(unsafe.Pointer(p2)) = int16(uint64(*(*int16)(unsafe.Pointer(p2))) - cnt) - if !(*(*int16)(unsafe.Pointer(p2)) != 0) { + v2 = b + 82 + *(*int16)(unsafe.Pointer(v2)) = int16(uint64(*(*int16)(unsafe.Pointer(v2))) - cnt) + if !(*(*int16)(unsafe.Pointer(v2)) != 0) { Xfree(tls, b) } else { ___unlock(tls, b+76) @@ -119544,7 +119544,7 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs)) - ecode++ + ecode = ecode + 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -119556,16 +119556,16 @@ func Xgai_strerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode++ - s++ + ecode = ecode + 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -119668,7 +119668,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _1 _1: ; - i++ + i = i + 1 } } nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags) @@ -119738,13 +119738,13 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt goto _4 _4: ; - j++ - k++ + j = j + 1 + k = k + 1 } goto _2 _2: ; - i++ + i = i + 1 } (*(*Taibuf)(unsafe.Pointer(out))).Fref = int16(nais) *(*uintptr)(unsafe.Pointer(res)) = out @@ -119875,7 +119875,7 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l Tsocklen_t, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h) - size += size + uint64(1) + size = size + (size + uint64(1)) _h = Xmalloc(tls, size) if !(_h != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -119940,15 +119940,15 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l Tsocklen_t, af int32, h uintptr, bu if buflen <= Uint64FromInt32(5)*Uint64FromInt64(8)-Uint64FromInt32(i)+uint64(l) { return int32(ERANGE) } - buf += uintptr(uint64(8) - Uint64FromInt32(i)) - buflen -= Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l) + buf = buf + uintptr(uint64(8)-Uint64FromInt32(i)) + buflen = buflen - (Uint64FromInt32(5)*Uint64FromInt64(8) - Uint64FromInt32(i) + uint64(l)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(2) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(2)*Uint64FromInt64(8)) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)) = buf Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list)), a, uint64(l)) - buf += uintptr(l) + buf = buf + uintptr(l) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + 1*8)) = uintptr(0) *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) @@ -119998,7 +119998,7 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) (r uintptr) { size = uint64(63) for cond := true; cond; cond = err == int32(ERANGE) { Xfree(tls, _h1) - size += size + uint64(1) + size = size + (size + uint64(1)) _h1 = Xmalloc(tls, size) if !(_h1 != 0) { *(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = int32(NO_RECOVERY) @@ -120057,41 +120057,41 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr, /* Align buffer */ align = -uint64(buf) & (Uint64FromInt64(8) - Uint64FromInt32(1)) need = Uint64FromInt32(4) * Uint64FromInt64(8) - need += Uint64FromInt32(cnt+Int32FromInt32(1)) * (uint64(8) + Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) - need += Xstrlen(tls, name) + uint64(1) - need += Xstrlen(tls, bp+1344) + uint64(1) - need += align + need = need + Uint64FromInt32(cnt+Int32FromInt32(1))*(uint64(8)+Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) + need = need + (Xstrlen(tls, name) + uint64(1)) + need = need + (Xstrlen(tls, bp+1344) + uint64(1)) + need = need + align if need > buflen { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) (*Thostent)(unsafe.Pointer(h)).Fh_aliases = buf - buf += uintptr(Uint64FromInt32(3) * Uint64FromInt64(8)) + buf = buf + uintptr(Uint64FromInt32(3)*Uint64FromInt64(8)) (*Thostent)(unsafe.Pointer(h)).Fh_addr_list = buf - buf += uintptr(Uint64FromInt32(cnt+Int32FromInt32(1)) * uint64(8)) + buf = buf + uintptr(Uint64FromInt32(cnt+Int32FromInt32(1))*uint64(8)) i = 0 for { if !(i < cnt) { break } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = buf - buf += uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) + buf = buf + uintptr((*Thostent)(unsafe.Pointer(h)).Fh_length) Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, Uint64FromInt32((*Thostent)(unsafe.Pointer(h)).Fh_length)) goto _2 _2: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_addr_list + uintptr(i)*8)) = uintptr(0) v3 = buf *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases)) = v3 (*Thostent)(unsafe.Pointer(h)).Fh_name = v3 Xstrcpy(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, bp+1344) - buf += uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name)+uint64(1)) if Xstrcmp(tls, (*Thostent)(unsafe.Pointer(h)).Fh_name, name) != 0 { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = buf Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)), name) - buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8))) + uint64(1)) + buf = buf + uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)))+uint64(1)) } else { *(*uintptr)(unsafe.Pointer((*Thostent)(unsafe.Pointer(h)).Fh_aliases + 1*8)) = uintptr(0) } @@ -120353,7 +120353,7 @@ func _gen_netmask(tls *TLS, r uintptr, af int32, sa uintptr, prefixlen int32) { Xmemset(tls, bp, int32(0xff), Uint64FromInt32(i)) if Uint64FromInt32(i) < uint64(16) { v1 = i - i++ + i = i + 1 (*(*[16]Tuint8_t)(unsafe.Pointer(bp)))[v1] = Uint8FromInt32(int32(0xff) << (int32(8) - prefixlen%int32(8))) } _copy_addr(tls, r, af, sa, bp, uint64(16), 0) @@ -120534,17 +120534,17 @@ func Xgetifaddrs(tls *TLS, ifap uintptr) (r1 int32) { const RR_PTR = 12 func _itoa(tls *TLS, p uintptr, x uint32) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 - p += uintptr(Uint64FromInt32(3) * Uint64FromInt64(4)) - p-- + var v1 uintptr + _ = v1 + p = p + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -120557,29 +120557,29 @@ func _mkptr4(tls *TLS, s uintptr, ip uintptr) { func _mkptr6(tls *TLS, s uintptr, ip uintptr) { var i int32 - var v2, v3, v4, v5 uintptr - _, _, _, _, _ = i, v2, v3, v4, v5 + var v2 uintptr + _, _ = i, v2 i = int32(15) for { if !(i >= 0) { break } v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&int32(15)] - v3 = s - s++ - *(*uint8)(unsafe.Pointer(v3)) = uint8('.') - v4 = s - s++ - *(*uint8)(unsafe.Pointer(v4)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] - v5 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = _xdigits[Int32FromUint8(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>int32(4)] + v2 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = uint8('.') goto _1 _1: ; - i-- + i = i - 1 } Xstrcpy(tls, s, __ccgo_ts+1037) } @@ -120589,15 +120589,15 @@ var _xdigits = [17]uint8{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { bp := tls.Alloc(1824) defer tls.Free(1824) - var f, p, z, v1, v2, v8 uintptr - var v10, v11, v15, v16, v4, v5 int32 - var v13, v18, v7 bool + var f, p, z, v1, v2 uintptr + var v4, v5 int32 + var v7 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1592 */ TFILE var _ /* atmp at bp+1544 */ [16]uint8 var _ /* iplit at bp+1560 */ Taddress var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, p, z, v1, v10, v11, v13, v15, v16, v18, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, z, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1046, bp+1592, bp+512, uint64(1032)) if !(f != 0) { return @@ -120612,7 +120612,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120630,14 +120630,14 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) if X__lookup_ipliteral(tls, bp+1560, bp, PF_UNSPEC) <= 0 { continue } @@ -120650,35 +120650,35 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int continue } for { - if v13 = *(*uint8)(unsafe.Pointer(p)) != 0; v13 { - v10 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v11 = BoolInt32(v10 == int32(' ') || Uint32FromInt32(v10)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(p)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _12 _12: } - if !(v13 && v11 != 0) { + if !(v7 && v5 != 0) { break } goto _9 _9: ; - p++ + p = p + 1 } z = p for { - if v18 = *(*uint8)(unsafe.Pointer(z)) != 0; v18 { - v15 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v16 = BoolInt32(v15 == int32(' ') || Uint32FromInt32(v15)-uint32('\t') < uint32(5)) + if v7 = *(*uint8)(unsafe.Pointer(z)) != 0; v7 { + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v5 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _17 _17: } - if !(v18 && !(v16 != 0)) { + if !(v7 && !(v5 != 0)) { break } goto _14 _14: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if int64(z)-int64(p) < int64(256) { @@ -120692,7 +120692,7 @@ func _reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { bp := tls.Alloc(1408) defer tls.Free(1408) - var f, p, v1, v2, v8 uintptr + var f, p, v1, v2 uintptr var svport uint64 var v4, v5 int32 var v7 bool @@ -120700,7 +120700,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { var _ /* _f at bp+1168 */ TFILE var _ /* line at bp+0 */ [128]uint8 var _ /* z at bp+128 */ uintptr - _, _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7, v8 + _, _, _, _, _, _, _, _ = f, p, svport, v1, v2, v4, v5, v7 f = X__fopen_rb_ca(tls, __ccgo_ts+1070, bp+1168, bp+136, uint64(1032)) if !(f != 0) { return @@ -120710,7 +120710,7 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } @@ -120728,14 +120728,14 @@ func _reverse_services(tls *TLS, buf uintptr, port int32, dgram int32) { goto _3 _3: ; - p++ + p = p + 1 } if !(*(*uint8)(unsafe.Pointer(p)) != 0) { continue } - v8 = p - p++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) svport = Xstrtoul(tls, p, bp+128, int32(10)) if svport != Uint64FromInt32(port) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { continue @@ -120835,7 +120835,7 @@ func Xgetnameinfo(tls *TLS, sa uintptr, sl Tsocklen_t, node uintptr, nodelen Tso if !(p != 0) { p = _itoa(tls, bp+334, scopeid) } - p-- + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8('%') Xstrcat(tls, bp+78, p) @@ -120964,7 +120964,7 @@ func Xgetservbyname_r(tls *TLS, name uintptr, prots uintptr, se uintptr, buf uin if buflen < Uint64FromInt32(2)*Uint64FromInt64(8)+Uint64FromInt32(align) { return int32(ERANGE) } - buf += uintptr(align) + buf = buf + uintptr(align) if !(prots != 0) { proto = 0 } else { @@ -121067,12 +121067,12 @@ func Xgetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(320) defer tls.Free(320) - var r, v10, v21, v32 int64 - var r1, v1, v12, v13, v14, v2, v23, v24, v25, v3 int32 + var r, v10 int64 + var r1, v1, v2, v3 int32 var tv uintptr - var v15, v16, v17, v18, v19, v20, v26, v27, v28, v29, v30, v31, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t var _ /* tv32 at bp+296 */ [2]int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v23, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, tv, v1, v10, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_getsockopt) v2 = int32(__SC_getsockopt) v3 = 0 @@ -121138,49 +121138,49 @@ _11: *(*[1]Tsocklen_t)(unsafe.Pointer(bp + 96)) = [1]Tsocklen_t{ 0: uint32(16), } - v12 = int32(SYS_getsockopt) - v13 = int32(__SC_getsockopt) - v14 = 0 - v15 = int64(fd) - v16 = int64(level) - v17 = int64(optname) - v18 = int64(bp + 296) - v19 = int64(bp + 96) - v20 = int64(Int32FromInt32(0)) - if v14 != 0 { - r = ___syscall_cp(tls, int64(v12), v15, v16, v17, v18, v19, v20) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(bp + 296) + v8 = int64(bp + 96) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v12), v15, v16, v17, v18, v19, v20) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v21 = r + v10 = r goto _22 } - if v14 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 200)) = [6]int64{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v13), int64(bp+200), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+200), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 248)) = [6]int64{ - 0: v15, - 1: v16, - 2: v17, - 3: v18, - 4: v19, - 5: v20, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v13), int64(bp+248)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+248)) } - v21 = r + v10 = r goto _22 _22: - r1 = int32(v21) + r1 = int32(v10) if r1 < 0 { break } @@ -121200,49 +121200,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v23 = int32(SYS_getsockopt) - v24 = int32(__SC_getsockopt) - v25 = 0 - v26 = int64(fd) - v27 = int64(level) - v28 = int64(optname) - v29 = int64(optval) - v30 = int64(optlen) - v31 = int64(Int32FromInt32(0)) - if v25 != 0 { - r = ___syscall_cp(tls, int64(v23), v26, v27, v28, v29, v30, v31) + v1 = int32(SYS_getsockopt) + v2 = int32(__SC_getsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(optval) + v8 = int64(optlen) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v23), v26, v27, v28, v29, v30, v31) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v32 = r + v10 = r goto _33 } - if v25 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 200)) = [6]int64{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v24), int64(bp+200), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+200), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 248)) = [6]int64{ - 0: v26, - 1: v27, - 2: v28, - 3: v29, - 4: v30, - 5: v31, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v24), int64(bp+248)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+248)) } - v32 = r + v10 = r goto _33 _33: - r1 = int32(v32) + r1 = int32(v10) break } } @@ -121292,7 +121292,7 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { var s uintptr _ = s s = uintptr(unsafe.Pointer(&_msgs1)) - ecode-- + ecode = ecode - 1 for { if !(ecode != 0 && *(*uint8)(unsafe.Pointer(s)) != 0) { break @@ -121304,16 +121304,16 @@ func Xhstrerror(tls *TLS, ecode int32) (r uintptr) { goto _2 _2: ; - s++ + s = s + 1 } goto _1 _1: ; - ecode-- - s++ + ecode = ecode - 1 + s = s + 1 } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -121484,7 +121484,7 @@ func _netlink_msg_to_nameindex(tls *TLS, pctx uintptr, h uintptr) (r int32) { (*Tifnamemap)(unsafe.Pointer(map1)).Fnamelen = Uint8FromInt32(namelen) Xmemcpy(tls, map1+9, rta+UintptrFromInt64(4), Uint64FromInt32(namelen)) *(*uint32)(unsafe.Pointer(ctx + 8)) += Uint32FromInt32(namelen + int32(1)) - (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum++ + (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum + 1 (*Tifnamemap)(unsafe.Pointer(map1)).Fhash_next = *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) *(*uint32)(unsafe.Pointer(ctx + 24 + uintptr(bucket)*4)) = (*Tifnameindexctx)(unsafe.Pointer(ctx)).Fnum return 0 @@ -121530,14 +121530,14 @@ func Xif_nameindex(tls *TLS) (r uintptr) { (*Tif_nameindex)(unsafe.Pointer(d)).Fif_index = (*Tifnamemap)(unsafe.Pointer(s)).Findex (*Tif_nameindex)(unsafe.Pointer(d)).Fif_name = p Xmemcpy(tls, p, s+9, uint64((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen)) - p += uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) + p = p + uintptr((*Tifnamemap)(unsafe.Pointer(s)).Fnamelen) v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) goto _1 _1: ; - i-- + i = i - 1 s += 28 d += 16 } @@ -121559,9 +121559,9 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { } bp := tls.Alloc(64) defer tls.Free(64) - var fd, r, v1, v2 int32 + var fd, r, v1 int32 var _ /* ifr at bp+0 */ Tifreq - _, _, _, _ = fd, r, v1, v2 + _, _, _ = fd, r, v1 v1 = Xsocket(tls, int32(PF_LOCAL), Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), 0) fd = v1 if v1 < 0 { @@ -121571,11 +121571,11 @@ func Xif_nametoindex(tls *TLS, name uintptr) (r1 uint32) { r = Xioctl(tls, fd, int32(SIOCGIFINDEX), VaList(bp+48, bp)) X__syscall1(tls, int64(SYS_close), int64(fd)) if r < 0 { - v2 = 0 + v1 = 0 } else { - v2 = *(*int32)(unsafe.Pointer(bp + 16)) + v1 = *(*int32)(unsafe.Pointer(bp + 16)) } - return Uint32FromInt32(v2) + return Uint32FromInt32(v1) } func Xinet_addr(tls *TLS, p uintptr) (r Tin_addr_t) { @@ -121623,7 +121623,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i == int32(4) { return 0 @@ -121653,7 +121653,7 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) (r int32) { goto _2 _2: ; - i++ + i = i + 1 } return int32(1) } @@ -121680,12 +121680,12 @@ func Xinet_makeaddr(tls *TLS, n Tin_addr_t, h Tin_addr_t) (r Tin_addr) { defer func() { trc("-> %v", r) }() } if n < uint32(256) { - h |= n << int32(24) + h = h | n< int32(3) { v3 = Uint8FromUint8(':') @@ -121812,7 +121812,7 @@ func _hexval(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -121826,11 +121826,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } bp := tls.Alloc(16) defer tls.Free(16) - var a, v14, v15, v4, v7 uintptr - var brk, d, i, j, need_v4, v, v10, v3, v9 int32 - var v11, v5 bool + var a, v4 uintptr + var brk, d, i, j, need_v4, v, v3, v9 int32 + var v5 bool var _ /* ip at bp+0 */ [8]Tuint16_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v10, v11, v14, v15, v3, v4, v5, v7, v9 + _, _, _, _, _, _, _, _, _, _, _ = a, brk, d, i, j, need_v4, v, v3, v4, v5, v9 a = a0 brk = -int32(1) need_v4 = 0 @@ -121851,7 +121851,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } if j == 0 || j > int32(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('0') || v > int32(255) { return 0 @@ -121863,11 +121863,11 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(j)))) != int32('.') { return 0 } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _1 _1: ; - i++ + i = i + 1 } return 0 } else { @@ -121877,7 +121877,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } } if v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':'); v5 { - s++ + s = s + 1 v4 = s } if v5 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32(':') { @@ -121888,9 +121888,9 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32(':') && brk < 0 { brk = i (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) - s++ - v7 = s - if !(*(*uint8)(unsafe.Pointer(v7)) != 0) { + s = s + 1 + v4 = s + if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { break } if i == int32(7) { @@ -121898,22 +121898,22 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { } goto _6 } - v9 = Int32FromInt32(0) - j = v9 - v = v9 + v3 = Int32FromInt32(0) + j = v3 + v = v3 for { - if v11 = j < int32(4); v11 { - v10 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) - d = v10 + if v5 = j < int32(4); v5 { + v9 = _hexval(tls, uint32(*(*uint8)(unsafe.Pointer(s + uintptr(j))))) + d = v9 } - if !(v11 && v10 >= 0) { + if !(v5 && v9 >= 0) { break } v = int32(16)*v + d goto _8 _8: ; - j++ + j = j + 1 } if j == 0 { return 0 @@ -121930,15 +121930,15 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { return 0 } need_v4 = int32(1) - i++ + i = i + 1 (*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[i&int32(7)] = uint16(0) break } - s += uintptr(j + int32(1)) + s = s + uintptr(j+int32(1)) goto _6 _6: ; - i++ + i = i + 1 } if brk >= 0 { Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, Uint64FromInt32(int32(2)*(i+int32(1)-brk))) @@ -121951,7 +121951,7 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { goto _12 _12: ; - j++ + j = j + 1 } } j = 0 @@ -121959,16 +121959,16 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) (r int32) { if !(j < int32(8)) { break } - v14 = a - a++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) - v15 = a - a++ - *(*uint8)(unsafe.Pointer(v15)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Int32FromUint16((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) >> int32(8)) + v4 = a + a = a + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8((*(*[8]Tuint16_t)(unsafe.Pointer(bp)))[j]) goto _13 _13: ; - j++ + j = j + 1 } if need_v4 != 0 && Xinet_pton(tls, int32(PF_INET), s, a-uintptr(4)) <= 0 { return 0 @@ -122071,7 +122071,7 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) (r i Xmemcpy(tls, buf+8, bp+4, uint64(16)) (*(*Taddress)(unsafe.Pointer(buf))).Ffamily = int32(PF_INET6) if p != 0 { - p++ + p = p + 1 v1 = p if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(v1)))-uint32('0') < uint32(10)) != 0 { scopeid = Xstrtoull(tls, p, bp+88, int32(10)) @@ -122121,14 +122121,14 @@ func _is_valid_hostname(tls *TLS, host uintptr) (r int32) { goto _1 _1: ; - s++ + s = s + 1 } return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0)) } func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int32) (r int32) { - var cnt, v1, v2, v3, v4 int32 - _, _, _, _, _ = cnt, v1, v2, v3, v4 + var cnt, v1 int32 + _, _ = cnt, v1 cnt = 0 if name != 0 { return 0 @@ -122136,23 +122136,23 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in if flags&int32(AI_PASSIVE) != 0 { if family != int32(PF_INET6) { v1 = cnt - cnt++ + cnt = cnt + 1 *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), } } if family != int32(PF_INET) { - v2 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v2)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), } } } else { if family != int32(PF_INET6) { - v3 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v3)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET), Faddr: [16]Tuint8_t{ 0: uint8(127), @@ -122161,9 +122161,9 @@ func _name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags in } } if family != int32(PF_INET) { - v4 = cnt - cnt++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = Taddress{ + v1 = cnt + cnt = cnt + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = Taddress{ Ffamily: int32(PF_INET6), Faddr: [16]Tuint8_t{ 15: uint8(1), @@ -122181,14 +122181,14 @@ func _name_from_numeric(tls *TLS, buf uintptr, name uintptr, family int32) (r in func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(1776) defer tls.Free(1776) - var badfam, cnt, have_canon, v14, v15, v20, v21, v25, v26, v29, v5, v6, v8, v9 int32 - var f, p, z, v1, v18, v2, v4 uintptr + var badfam, cnt, have_canon, v5, v6, v8, v9 int32 + var f, p, z, v1, v2 uintptr var l Tsize_t - var v11, v12, v17, v23, v28 bool + var v11, v12 bool var _ /* _buf at bp+512 */ [1032]uint8 var _ /* _f at bp+1544 */ TFILE var _ /* line at bp+0 */ [512]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v14, v15, v17, v18, v2, v20, v21, v23, v25, v26, v28, v29, v4, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = badfam, cnt, f, have_canon, l, p, z, v1, v11, v12, v2, v5, v6, v8, v9 l = Xstrlen(tls, name) cnt = 0 badfam = 0 @@ -122211,15 +122211,15 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family p = v1 if v1 != 0 { v2 = p - p++ + p = p + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8('\n') *(*uint8)(unsafe.Pointer(p)) = Uint8FromInt32(0) } p = bp + uintptr(1) for { - v4 = Xstrstr(tls, p, name) - p = v4 - if v12 = v4 != 0; v12 { + v1 = Xstrstr(tls, p, name) + p = v1 + if v12 = v1 != 0; v12 { v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _7 @@ -122238,7 +122238,7 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family goto _3 _3: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -122246,26 +122246,26 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family /* Isolate IP address to parse */ p = bp for { - if v17 = *(*uint8)(unsafe.Pointer(p)) != 0; v17 { - v14 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v15 = BoolInt32(v14 == int32(' ') || Uint32FromInt32(v14)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _16 _16: } - if !(v17 && !(v15 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _13 _13: ; - p++ + p = p + 1 } - v18 = p - p++ - *(*uint8)(unsafe.Pointer(v18)) = uint8(0) + v1 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) switch _name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) { case int32(1): - cnt++ + cnt = cnt + 1 case 0: continue default: @@ -122277,35 +122277,35 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } /* Extract first name as canonical name */ for { - if v23 = *(*uint8)(unsafe.Pointer(p)) != 0; v23 { - v20 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(p)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _22 _22: } - if !(v23 && v21 != 0) { + if !(v11 && v6 != 0) { break } goto _19 _19: ; - p++ + p = p + 1 } z = p for { - if v28 = *(*uint8)(unsafe.Pointer(z)) != 0; v28 { - v25 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v26 = BoolInt32(v25 == int32(' ') || Uint32FromInt32(v25)-uint32('\t') < uint32(5)) + if v11 = *(*uint8)(unsafe.Pointer(z)) != 0; v11 { + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _27 _27: } - if !(v28 && !(v26 != 0)) { + if !(v11 && !(v6 != 0)) { break } goto _24 _24: ; - z++ + z = z + 1 } *(*uint8)(unsafe.Pointer(z)) = uint8(0) if _is_valid_hostname(tls, p) != 0 { @@ -122315,11 +122315,11 @@ func _name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family } X__fclose_ca(tls, f) if cnt != 0 { - v29 = cnt + v5 = cnt } else { - v29 = badfam + v5 = badfam } - return v29 + return v5 } type Tdpc_ctx = struct { @@ -122366,7 +122366,7 @@ func _dns_parse_callback1(tls *TLS, c uintptr, rr int32, data uintptr, len1 int3 (*(*Taddress)(unsafe.Pointer((*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs + uintptr((*Tdpc_ctx)(unsafe.Pointer(ctx)).Fcnt)*28))).Fscopeid = uint32(0) v2 = ctx + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 Xmemcpy(tls, (*Tdpc_ctx)(unsafe.Pointer(ctx)).Faddrs+uintptr(v1)*28+8, data, Uint64FromInt32(len1)) return 0 } @@ -122411,14 +122411,14 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280 + 3)) = uint8(0) /* don't need AD flag */ /* Ensure query IDs are distinct. */ if nq != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(bp))) { - *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280))++ + *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) = *(*uint8)(unsafe.Pointer(bp + uintptr(nq)*280)) + 1 } - nq++ + nq = nq + 1 } goto _1 _1: ; - i++ + i = i + 1 } if X__res_msend_rc(tls, nq, bp+10160, bp+10192, bp+10176, bp+10200, int32(4800), conf) < 0 { return -int32(11) @@ -122440,7 +122440,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } i = nq - int32(1) for { @@ -122455,7 +122455,7 @@ func _name_from_dns(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _3 _3: ; - i-- + i = i - 1 } if (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt != 0 { return (*(*Tdpc_ctx)(unsafe.Pointer(bp + 10208))).Fcnt @@ -122480,13 +122480,13 @@ var _afrr = [2]struct { func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32) (r int32) { bp := tls.Alloc(368) defer tls.Free(368) - var cnt, v10, v5, v6, v9 int32 + var cnt, v5, v6 int32 var dots, l, v2 Tsize_t var p, z uintptr var v12 bool var _ /* conf at bp+256 */ Tresolvconf var _ /* search at bp+0 */ [256]uint8 - _, _, _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v10, v12, v2, v5, v6, v9 + _, _, _, _, _, _, _, _, _ = cnt, dots, l, p, z, v12, v2, v5, v6 if X__get_resolv_conf(tls, bp+256, bp, uint64(256)) < 0 { return -int32(1) } @@ -122500,19 +122500,19 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l)))) == int32('.') { - dots++ + dots = dots + 1 } goto _1 _1: ; - l++ + l = l + 1 } if dots >= uint64((*(*Tresolvconf)(unsafe.Pointer(bp + 256))).Fndots) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { *(*uint8)(unsafe.Pointer(bp)) = uint8(0) } /* Strip final dot for canon, fail if multiple trailing dots. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if !(l != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(name + uintptr(l-uint64(1))))) == int32('.') { return -int32(2) @@ -122543,23 +122543,23 @@ func _name_from_dns_search(tls *TLS, buf uintptr, canon uintptr, name uintptr, f goto _4 _4: ; - p++ + p = p + 1 } z = p for { if v12 = *(*uint8)(unsafe.Pointer(z)) != 0; v12 { - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) - v10 = BoolInt32(v9 == int32(' ') || Uint32FromInt32(v9)-uint32('\t') < uint32(5)) + v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(z))) + v6 = BoolInt32(v5 == int32(' ') || Uint32FromInt32(v5)-uint32('\t') < uint32(5)) goto _11 _11: } - if !(v12 && !(v10 != 0)) { + if !(v12 && !(v6 != 0)) { break } goto _8 _8: ; - z++ + z = z + 1 } if z == p { break @@ -122645,7 +122645,7 @@ func _policyof(tls *TLS, a uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return r } @@ -122681,7 +122681,7 @@ func _prefixmatch(tls *TLS, s uintptr, d uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return Int32FromUint32(i) } @@ -122701,7 +122701,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i } bp := tls.Alloc(96) defer tls.Free(96) - var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1, v4, v5 int32 + var cnt, dlabel, dprec, dscope, family1, fd, i, j, key, prefixlen, v1 int32 var da, dpolicy, sa uintptr var dalen Tsocklen_t var l Tsize_t @@ -122711,7 +122711,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i var _ /* sa4 at bp+60 */ Tsockaddr_in var _ /* sa6 at bp+4 */ Tsockaddr_in6 var _ /* salen at bp+92 */ Tsocklen_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1, v4, v5 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, da, dalen, dlabel, dpolicy, dprec, dscope, family1, fd, i, j, key, l, prefixlen, sa, v1 cnt = 0 *(*uint8)(unsafe.Pointer(canon)) = uint8(0) if name != 0 { @@ -122729,7 +122729,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i if family == int32(PF_INET6) { family = PF_UNSPEC } else { - flags -= int32(AI_V4MAPPED) + flags = flags - int32(AI_V4MAPPED) } } /* Try each backend until there's at least one result. */ @@ -122763,7 +122763,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _2 _2: ; - i++ + i = i + 1 } if i < cnt { j = 0 @@ -122772,18 +122772,18 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i break } if (*(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28))).Ffamily == int32(PF_INET6) { - v4 = j - j++ - *(*Taddress)(unsafe.Pointer(buf + uintptr(v4)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) + v1 = j + j = j + 1 + *(*Taddress)(unsafe.Pointer(buf + uintptr(v1)*28)) = *(*Taddress)(unsafe.Pointer(buf + uintptr(i)*28)) } goto _3 _3: ; - i++ + i = i + 1 } - v5 = j - i = v5 - cnt = v5 + v1 = j + i = v1 + cnt = v1 } } /* Translate any remaining v4 results to v6 */ @@ -122801,7 +122801,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _6 _6: ; - i++ + i = i + 1 } } /* No further processing is needed if there are fewer than 2 @@ -122820,7 +122820,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i goto _7 _7: ; - i++ + i = i + 1 } if i == cnt { return cnt @@ -122874,31 +122874,31 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i fd = Xsocket(tls, family1, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC), int32(IPPROTO_UDP)) if fd >= 0 { if !(Xconnect(tls, fd, da, dalen) != 0) { - key |= int32(DAS_USABLE) + key = key | int32(DAS_USABLE) if !(Xgetsockname(tls, fd, sa, bp+92) != 0) { if family1 == int32(PF_INET) { Xmemcpy(tls, bp+4+8+uintptr(12), bp+60+4, uint64(4)) } if dscope == _scopeof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGSCOPE) + key = key | int32(DAS_MATCHINGSCOPE) } if dlabel == _labelof(tls, bp+4+8) { - key |= int32(DAS_MATCHINGLABEL) + key = key | int32(DAS_MATCHINGLABEL) } prefixlen = _prefixmatch(tls, bp+4+8, bp+32+8) } } Xclose(tls, fd) } - key |= dprec << int32(DAS_PREC_SHIFT) - key |= (int32(15) - dscope) << int32(DAS_SCOPE_SHIFT) - key |= prefixlen << int32(DAS_PREFIX_SHIFT) - key |= (int32(MAXADDRS) - i) << DAS_ORDER_SHIFT + key = key | dprec< bp; v10 { - v7 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) - v8 = BoolInt32(v7 == int32(' ') || Uint32FromInt32(v7)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _9 _9: } - if v10 && !(v8 != 0) { + if v10 && !(v2 != 0) { goto _5 } - if v14 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v14 { - v11 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) - v12 = BoolInt32(v11 == int32(' ') || Uint32FromInt32(v11)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p + uintptr(l))) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(l)))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _13 _13: } - if v14 && !(v12 != 0) { + if v10 && !(v2 != 0) { goto _5 } break goto _5 _5: ; - p++ + p = p + 1 } if !(p != 0) { continue @@ -123045,19 +123045,19 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i /* Skip past canonical name at beginning of line */ p = bp for { - if v19 = *(*uint8)(unsafe.Pointer(p)) != 0; v19 { - v16 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v17 = BoolInt32(v16 == int32(' ') || Uint32FromInt32(v16)-uint32('\t') < uint32(5)) + if v10 = *(*uint8)(unsafe.Pointer(p)) != 0; v10 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _18 _18: } - if !(v19 && !(v17 != 0)) { + if !(v10 && !(v2 != 0)) { break } goto _15 _15: ; - p++ + p = p + 1 } port = Xstrtoul(tls, p, bp+128, int32(10)) if port > uint64(65535) || *(*uintptr)(unsafe.Pointer(bp + 128)) == p { @@ -123069,9 +123069,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_DGRAM) - v20 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v20)*4))).Fproto = uint8(IPPROTO_UDP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_UDP) } if !(Xstrncmp(tls, *(*uintptr)(unsafe.Pointer(bp + 128)), __ccgo_ts+1089, uint64(4)) != 0) { if proto == int32(IPPROTO_UDP) { @@ -123079,18 +123079,18 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i } (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fport = uint16(port) (*(*Tservice)(unsafe.Pointer(buf + uintptr(cnt)*4))).Fsocktype = uint8(SOCK_STREAM) - v21 = cnt - cnt++ - (*(*Tservice)(unsafe.Pointer(buf + uintptr(v21)*4))).Fproto = uint8(IPPROTO_TCP) + v1 = cnt + cnt = cnt + 1 + (*(*Tservice)(unsafe.Pointer(buf + uintptr(v1)*4))).Fproto = uint8(IPPROTO_TCP) } } X__fclose_ca(tls, f) if cnt > 0 { - v22 = cnt + v1 = cnt } else { - v22 = -int32(8) + v1 = -int32(8) } - return v22 + return v1 } func ___netlink_enumerate(tls *TLS, fd int32, seq uint32, type1 int32, af int32, __ccgo_fp_cb uintptr, ctx uintptr) (r1 int32) { @@ -123253,34 +123253,34 @@ func Xns_put16(tls *TLS, s uint32, cp uintptr) { if __ccgo_strace { trc("tls=%v s=%v cp=%v, (%v:)", tls, s, cp, origin(2)) } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(s >> int32(8)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(s) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(s) } func Xns_put32(tls *TLS, l uint64, cp uintptr) { if __ccgo_strace { trc("tls=%v l=%v cp=%v, (%v:)", tls, l, cp, origin(2)) } - var v1, v2, v3, v4 uintptr - _, _, _, _ = v1, v2, v3, v4 + var v1 uintptr + _ = v1 v1 = cp - cp++ + cp = cp + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(24)) - v2 = cp - cp++ - *(*uint8)(unsafe.Pointer(v2)) = uint8(l >> int32(16)) - v3 = cp - cp++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(l >> int32(8)) - v4 = cp - cp++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(l) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(16)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l >> int32(8)) + v1 = cp + cp = cp + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(l) } func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int32) { @@ -123295,21 +123295,21 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if msglen < (Int32FromInt32(2)+int32(_ns_s_max))*Int32FromInt32(NS_INT16SZ) { goto bad } - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_id = uint16(Xns_get16(tls, msg-uintptr(2))) - msg += uintptr(2) + msg = msg + uintptr(2) (*Tns_msg)(unsafe.Pointer(handle)).F_flags = uint16(Xns_get16(tls, msg-uintptr(2))) i = 0 for { if !(i < int32(_ns_s_max)) { break } - msg += uintptr(2) + msg = msg + uintptr(2) *(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(i)*2)) = uint16(Xns_get16(tls, msg-uintptr(2))) goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -123322,14 +123322,14 @@ func Xns_initparse(tls *TLS, msg uintptr, msglen int32, handle uintptr) (r1 int3 if r < 0 { return -int32(1) } - msg += uintptr(r) + msg = msg + uintptr(r) } else { *(*uintptr)(unsafe.Pointer(handle + 32 + uintptr(i)*8)) = UintptrFromInt32(0) } goto _2 _2: ; - i++ + i = i + 1 } if msg != (*Tns_msg)(unsafe.Pointer(handle)).F_eom { goto bad @@ -123356,7 +123356,7 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 p = ptr for { v1 = count - count-- + count = count - 1 if !(v1 != 0) { break } @@ -123367,18 +123367,18 @@ func Xns_skiprr(tls *TLS, ptr uintptr, eom uintptr, section Tns_sect, count int3 if int64(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(r + Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) + p = p + uintptr(r+Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64(eom)-int64(p) { goto bad } - p += uintptr(NS_INT32SZ) - p += uintptr(2) + p = p + uintptr(NS_INT32SZ) + p = p + uintptr(2) r = Int32FromUint32(Xns_get16(tls, p-uintptr(2))) if int64(r) > int64(eom)-int64(p) { goto bad } - p += uintptr(r) + p = p + uintptr(r) } } return int32(int64(p) - int64(ptr)) @@ -123395,8 +123395,8 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin defer func() { trc("-> %v", r1) }() } var r int32 - var p1, p2, p3, p4 uintptr - _, _, _, _, _ = r, p1, p2, p3, p4 + var v1 uintptr + _, _ = r, v1 if section < 0 || section >= int32(_ns_s_max) { goto bad } @@ -123431,22 +123431,22 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin if int64(Int32FromInt32(2)*Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p1 = handle + 72 - *(*uintptr)(unsafe.Pointer(p1)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p1))-uintptr(2))) - p2 = handle + 72 - *(*uintptr)(unsafe.Pointer(p2)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p2))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Ftype1 = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frr_class = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if section != int32(_ns_s_qd) { if int64(Int32FromInt32(NS_INT32SZ)+Int32FromInt32(NS_INT16SZ)) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } - p3 = handle + 72 - *(*uintptr)(unsafe.Pointer(p3)) += uintptr(4) - (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(p3))-uintptr(4))) - p4 = handle + 72 - *(*uintptr)(unsafe.Pointer(p4)) += uintptr(2) - (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(p4))-uintptr(2))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(4) + (*Tns_rr)(unsafe.Pointer(rr)).Fttl = uint32(Xns_get32(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(4))) + v1 = handle + 72 + *(*uintptr)(unsafe.Pointer(v1)) += uintptr(2) + (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(Xns_get16(tls, *(*uintptr)(unsafe.Pointer(v1))-uintptr(2))) if Int64FromUint16((*Tns_rr)(unsafe.Pointer(rr)).Frdlength) > int64((*Tns_msg)(unsafe.Pointer(handle)).F_eom)-int64((*Tns_msg)(unsafe.Pointer(handle)).F_msg_ptr) { goto size } @@ -123457,7 +123457,7 @@ func Xns_parserr(tls *TLS, handle uintptr, section Tns_sect, rrnum int32, rr uin (*Tns_rr)(unsafe.Pointer(rr)).Frdlength = uint16(0) (*Tns_rr)(unsafe.Pointer(rr)).Frdata = UintptrFromInt32(0) } - (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum++ + (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum = (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum + 1 if (*Tns_msg)(unsafe.Pointer(handle)).F_rrnum > Int32FromUint16(*(*Tuint16_t)(unsafe.Pointer(handle + 20 + uintptr(section)*2))) { (*Tns_msg)(unsafe.Pointer(handle)).F_sect = section + int32(1) if (*Tns_msg)(unsafe.Pointer(handle)).F_sect == int32(_ns_s_max) { @@ -123580,7 +123580,7 @@ func Xgetprotoent(tls *TLS) (r uintptr) { _p.Fp_proto = Int32FromUint8(_protos[_idx]) _p.Fp_name = uintptr(unsafe.Pointer(&_protos)) + uintptr(_idx+int32(1)) _p.Fp_aliases = uintptr(unsafe.Pointer(&_aliases)) - _idx = int32(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) + _idx = Int32FromUint64(uint64(_idx) + (Xstrlen(tls, _p.Fp_name) + Uint64FromInt32(2))) return uintptr(unsafe.Pointer(&_p)) } @@ -123701,7 +123701,7 @@ func Xrecvmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32, ti goto _1 _1: ; - i-- + i = i - 1 mh += 64 } return int32(X__syscall_ret(tls, Uint64FromInt64(___syscall_cp(tls, int64(SYS_recvmmsg), int64(fd), int64(msgvec), Int64FromUint32(vlen), Int64FromUint32(flags), int64(timeout), 0)))) @@ -123713,11 +123713,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var cmsg, last, v2, v6, v8, p7 uintptr + var cmsg, last, v2 uintptr var type1 int32 var _ /* tmp at bp+0 */ int64 var _ /* tvts at bp+8 */ [2]int64 - _, _, _, _, _, _, _ = cmsg, last, type1, v2, v6, v8, p7 + _, _, _, _ = cmsg, last, type1, v2 if true { return } @@ -123769,11 +123769,11 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { _1: ; if uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(cmsg)) { - v6 = uintptr(0) + v2 = uintptr(0) } else { - v6 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = cmsg + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v6 + cmsg = v2 } if !(last != 0) || !(type1 != 0) { return @@ -123782,14 +123782,14 @@ func X__convert_scm_timestamps(tls *TLS, msg uintptr, csize Tsocklen_t) { *(*int32)(unsafe.Pointer(msg + 48)) |= int32(MSG_CTRUNC) return } - p7 = msg + 44 - *(*Tsocklen_t)(unsafe.Pointer(p7)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(p7))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = msg + 44 + *(*Tsocklen_t)(unsafe.Pointer(v2)) = Tsocklen_t(uint64(*(*Tsocklen_t)(unsafe.Pointer(v2))) + ((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + (Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)))) if uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen))-int64(last)) { - v8 = uintptr(0) + v2 = uintptr(0) } else { - v8 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v2 = last + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(last)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - cmsg = v8 + cmsg = v2 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_level = int32(SOL_SOCKET) (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_type = type1 (*Tcmsghdr)(unsafe.Pointer(cmsg)).Fcmsg_len = uint32((Uint64FromInt64(16)+Uint64FromInt64(8)-Uint64FromInt32(1)) & ^(Uint64FromInt64(8)-Uint64FromInt32(1)) + Uint64FromInt64(16)) @@ -123807,10 +123807,10 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { var orig_controllen Tsocklen_t var r, v11 int64 var r1 Tssize_t - var v1, v2, v3, v4 int32 + var v1, v2, v3 int32 var v10, v5, v6, v7, v8, v9 Tsyscall_arg_t var _ /* h at bp+96 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v10, v11, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = orig, orig_controllen, r, r1, v1, v10, v11, v2, v3, v5, v6, v7, v8, v9 orig_controllen = (*Tmsghdr)(unsafe.Pointer(msg)).Fmsg_controllen orig = msg if msg != 0 { @@ -123820,25 +123820,25 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { (*(*Tmsghdr)(unsafe.Pointer(bp + 96))).F__pad1 = v1 msg = bp + 96 } - v2 = int32(SYS_recvmsg) - v3 = int32(__SC_recvmsg) - v4 = int32(1) + v1 = int32(SYS_recvmsg) + v2 = int32(__SC_recvmsg) + v3 = int32(1) v5 = int64(fd) v6 = int64(msg) v7 = int64(flags) v8 = int64(Int32FromInt32(0)) v9 = int64(Int32FromInt32(0)) v10 = int64(Int32FromInt32(0)) - if v4 != 0 { - r = ___syscall_cp(tls, int64(v2), v5, v6, v7, v8, v9, v10) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v5, v6, v7, v8, v9, v10) } else { - r = X__syscall6(tls, int64(v2), v5, v6, v7, v8, v9, v10) + r = X__syscall6(tls, int64(v1), v5, v6, v7, v8, v9, v10) } if r != int64(-Int32FromInt32(ENOSYS)) { v11 = r goto _12 } - if v4 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp)) = [6]int64{ 0: v5, 1: v6, @@ -123847,7 +123847,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { 4: v9, 5: v10, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v3), int64(bp), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 48)) = [6]int64{ 0: v5, @@ -123857,7 +123857,7 @@ func Xrecvmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r2 Tssize_t) { 4: v9, 5: v10, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v3), int64(bp+48)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+48)) } v11 = r goto _12 @@ -123894,7 +123894,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, _, _, _, _, _ = i, id, j, l, n l = Xstrnlen(tls, dname, uint64(255)) if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { - l-- + l = l - 1 } if l != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(dname + uintptr(l-uint64(1))))) == int32('.') { return -int32(1) @@ -123922,7 +123922,7 @@ func X__res_mkquery(tls *TLS, op int32, dname uintptr, class int32, type1 int32, goto _2 _2: ; - j++ + j = j + 1 } if Uint32FromInt32(j-i)-uint32(1) > uint32(62) { return -int32(1) @@ -124065,7 +124065,7 @@ func _cleanup(tls *TLS, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } } @@ -124133,9 +124133,9 @@ func _start_tcp(tls *TLS, pfd uintptr, family int32, sa uintptr, sl Tsocklen_t, func _step_mh(tls *TLS, mh uintptr, n Tsize_t) { /* Adjust iovec in msghdr to skip first n bytes. */ for (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0 && n >= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len { - n -= (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len + n = n - (*Tiovec)(unsafe.Pointer((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov)).Fiov_len (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iov += 16 - (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen-- + (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen = (*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen - 1 } if !((*Tmsghdr)(unsafe.Pointer(mh)).Fmsg_iovlen != 0) { return @@ -124155,7 +124155,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a } bp := tls.Alloc(400) defer tls.Free(400) - var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v17, v6 int32 + var alen, attempts, family, fd, i, j, next, nns, r, rcode, retry_interval, rlen, servfail_retry, timeout, v6 int32 var alen_buf, apos, iplit, pfd, qpos uintptr var sl Tsocklen_t var t0, t1, t2, v10 uint64 @@ -124176,7 +124176,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a Fsin Tsockaddr_in F__ccgo_pad2 [12]byte } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v17, v18, v2, v3, v4, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alen, alen_buf, apos, attempts, family, fd, i, iplit, j, next, nns, pfd, qpos, r, rcode, retry_interval, rlen, servfail_retry, sl, t0, t1, t2, timeout, v1, v10, v18, v2, v3, v4, v6 defer func() { Xrealloc(tls, alen_buf, 0) Xrealloc(tls, apos, 0) @@ -124246,7 +124246,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _5 _5: ; - nns++ + nns = nns + 1 } /* Get local address and open/bind a socket */ fd = Xsocket(tls, family, Int32FromInt32(SOCK_DGRAM)|Int32FromInt32(SOCK_CLOEXEC)|Int32FromInt32(SOCK_NONBLOCK), 0) @@ -124260,7 +124260,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _7 _7: ; - i++ + i = i + 1 } if i == nns { _pthread_setcancelstate(tls, *(*int32)(unsafe.Pointer(bp + 200)), uintptr(0)) @@ -124294,7 +124294,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _8 _8: ; - i++ + i = i + 1 } } (*(*struct { @@ -124321,7 +124321,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _9 _9: ; - i++ + i = i + 1 } (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Ffd = fd (*(*Tpollfd)(unsafe.Add(unsafe.Pointer(pfd), nqueries*8))).Fevents = int16(POLLIN) @@ -124349,7 +124349,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _12 _12: ; - i++ + i = i + 1 } if i == nqueries { break @@ -124371,13 +124371,13 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _14 _14: ; - j++ + j = j + 1 } } goto _13 _13: ; - i++ + i = i + 1 } t1 = t2 servfail_retry = int32(2) * nqueries @@ -124416,7 +124416,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _15 _15: ; - j++ + j = j + 1 } if j == nns { continue @@ -124430,7 +124430,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _16 _16: ; - i++ + i = i + 1 } if i == nqueries { continue @@ -124447,10 +124447,10 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a case int32(3): case int32(2): if v18 = servfail_retry != 0; v18 { - v17 = servfail_retry - servfail_retry-- + v6 = servfail_retry + servfail_retry = servfail_retry - 1 } - if v18 && v17 != 0 { + if v18 && v6 != 0 { Xsendto(tls, fd, *(*uintptr)(unsafe.Pointer(queries + uintptr(i)*8)), Uint64FromInt32(*(*int32)(unsafe.Pointer(qlens + uintptr(i)*4))), int32(MSG_NOSIGNAL), bp+116+uintptr(j)*28, sl) } fallthrough @@ -124468,7 +124468,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _19 _19: ; - next++ + next = next + 1 } } else { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(answers + uintptr(i)*8)), *(*uintptr)(unsafe.Pointer(answers + uintptr(next)*8)), Uint64FromInt32(rlen)) @@ -124527,7 +124527,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _20 _20: ; - i++ + i = i + 1 } i = 0 for { @@ -124579,7 +124579,7 @@ func X__res_msend_rc(tls *TLS, nqueries int32, queries uintptr, qlens uintptr, a goto _21 _21: ; - i++ + i = i + 1 } goto _11 _11: @@ -124602,7 +124602,7 @@ out: goto _22 _22: ; - i++ + i = i + 1 } return 0 } @@ -124632,9 +124632,9 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen *(*int32)(unsafe.Pointer(bp + 8)) = _msglen *(*uintptr)(unsafe.Pointer(bp + 16)) = _answer *(*int32)(unsafe.Pointer(bp + 24)) = _anslen - var r, v1, v2 int32 + var r, v1 int32 var _ /* buf at bp+28 */ [512]uint8 - _, _, _ = r, v1, v2 + _, _ = r, v1 if *(*int32)(unsafe.Pointer(bp + 24)) < int32(512) { r = X__res_send(tls, *(*uintptr)(unsafe.Pointer(bp)), *(*int32)(unsafe.Pointer(bp + 8)), bp+28, int32(512)) if r >= 0 { @@ -124649,11 +124649,11 @@ func X__res_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen } r = X__res_msend(tls, int32(1), bp, bp+8, bp+16, bp+24, *(*int32)(unsafe.Pointer(bp + 24))) if r < 0 || !(*(*int32)(unsafe.Pointer(bp + 24)) != 0) { - v2 = -int32(1) + v1 = -int32(1) } else { - v2 = *(*int32)(unsafe.Pointer(bp + 24)) + v1 = *(*int32)(unsafe.Pointer(bp + 24)) } - return v2 + return v1 } func Xres_send(tls *TLS, _msg uintptr, _msglen int32, _answer uintptr, _anslen int32) (r int32) { @@ -124683,16 +124683,16 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } bp := tls.Alloc(752) defer tls.Free(752) - var c, nns, v1, v13, v14, v17, v18, v2, v21, v22, v26, v27, v8, v9 int32 + var c, nns, v1, v2 int32 var f, p uintptr var l Tsize_t - var x, x1, x2, v5, v6, v7 uint64 - var v11, v20, v24, v4 bool + var x, x1, x2, v5 uint64 + var v4 bool var _ /* _buf at bp+256 */ [256]uint8 var _ /* _f at bp+512 */ TFILE var _ /* line at bp+0 */ [256]uint8 var _ /* z at bp+744 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v11, v13, v14, v17, v18, v2, v20, v21, v22, v24, v26, v27, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, f, l, nns, p, x, x1, x2, v1, v2, v4, v5 nns = 0 (*Tresolvconf)(unsafe.Pointer(conf)).Fndots = uint32(1) (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(5) @@ -124729,7 +124729,7 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ if v4 && v2 != 0 { p = Xstrstr(tls, bp, __ccgo_ts+1204) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 6)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(6) + p = p + uintptr(6) x = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x > uint64(15) { @@ -124742,103 +124742,103 @@ func X__get_resolv_conf(tls *TLS, conf uintptr, search uintptr, search_sz Tsize_ } p = Xstrstr(tls, bp, __ccgo_ts+1211) if p != 0 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 9)))-uint32('0') < uint32(10)) != 0 { - p += uintptr(9) + p = p + uintptr(9) x1 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x1 > uint64(10) { - v6 = uint64(10) + v5 = uint64(10) } else { - v6 = x1 + v5 = x1 } - (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v6) + (*Tresolvconf)(unsafe.Pointer(conf)).Fattempts = uint32(v5) } } p = Xstrstr(tls, bp, __ccgo_ts+1221) if p != 0 && (BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p + 8)))-uint32('0') < uint32(10)) != 0 || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 8))) == int32('.')) { - p += uintptr(8) + p = p + uintptr(8) x2 = Xstrtoul(tls, p, bp+744, int32(10)) if *(*uintptr)(unsafe.Pointer(bp + 744)) != p { if x2 > uint64(60) { - v7 = uint64(60) + v5 = uint64(60) } else { - v7 = x2 + v5 = x2 } - (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v7) + (*Tresolvconf)(unsafe.Pointer(conf)).Ftimeout = uint32(v5) } } continue } - if v11 = !(Xstrncmp(tls, bp, __ccgo_ts+1230, uint64(10)) != 0); v11 { - v8 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) - v9 = BoolInt32(v8 == int32(' ') || Uint32FromInt32(v8)-uint32('\t') < uint32(5)) + if v4 = !(Xstrncmp(tls, bp, __ccgo_ts+1230, uint64(10)) != 0); v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(10)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _10 _10: } - if v11 && v9 != 0 { + if v4 && v2 != 0 { if nns >= int32(MAXNS) { continue } p = bp + uintptr(11) for { - v13 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v14 = BoolInt32(v13 == int32(' ') || Uint32FromInt32(v13)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _15 _15: - if !(v14 != 0) { + if !(v2 != 0) { break } goto _12 _12: ; - p++ + p = p + 1 } *(*uintptr)(unsafe.Pointer(bp + 744)) = p for { - if v20 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v20 { - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) - v18 = BoolInt32(v17 == int32(' ') || Uint32FromInt32(v17)-uint32('\t') < uint32(5)) + if v4 = *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) != 0; v4 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744))))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _19 _19: } - if !(v20 && !(v18 != 0)) { + if !(v4 && !(v2 != 0)) { break } goto _16 _16: ; - *(*uintptr)(unsafe.Pointer(bp + 744))++ + *(*uintptr)(unsafe.Pointer(bp + 744)) = *(*uintptr)(unsafe.Pointer(bp + 744)) + 1 } *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 744)))) = uint8(0) if X__lookup_ipliteral(tls, conf+uintptr(nns)*28, p, PF_UNSPEC) > 0 { - nns++ + nns = nns + 1 } continue } if !(search != 0) { continue } - if v24 = Xstrncmp(tls, bp, __ccgo_ts+1241, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1248, uint64(6)) != 0; !v24 { - v21 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) - v22 = BoolInt32(v21 == int32(' ') || Uint32FromInt32(v21)-uint32('\t') < uint32(5)) + if v4 = Xstrncmp(tls, bp, __ccgo_ts+1241, uint64(6)) != 0 && Xstrncmp(tls, bp, __ccgo_ts+1248, uint64(6)) != 0; !v4 { + v1 = Int32FromUint8((*(*[256]uint8)(unsafe.Pointer(bp)))[int32(6)]) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _23 _23: } - if v24 || !(v22 != 0) { + if v4 || !(v2 != 0) { continue } p = bp + uintptr(7) for { - v26 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v27 = BoolInt32(v26 == int32(' ') || Uint32FromInt32(v26)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _28 _28: - if !(v27 != 0) { + if !(v2 != 0) { break } goto _25 _25: ; - p++ + p = p + 1 } l = Xstrlen(tls, p) /* This can never happen anyway with chosen buffer sizes. */ @@ -124898,7 +124898,7 @@ func Xsendmmsg(tls *TLS, fd int32, msgvec uintptr, vlen uint32, flags uint32) (r goto _1 _1: ; - i++ + i = i + 1 } goto error error: @@ -124919,13 +124919,13 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { } bp := tls.Alloc(1216) defer tls.Free(1216) - var c1, v3, v4 uintptr + var c1, v3 uintptr var r, v14 int64 - var v1, v5, v6, v7 int32 + var v1, v5, v6 int32 var v10, v11, v12, v13, v8, v9 Tsyscall_arg_t var _ /* chbuf at bp+152 */ [66]Tcmsghdr var _ /* h at bp+96 */ Tmsghdr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c1, r, v1, v10, v11, v12, v13, v14, v3, v5, v6, v8, v9 if msg != 0 { *(*Tmsghdr)(unsafe.Pointer(bp + 96)) = *(*Tmsghdr)(unsafe.Pointer(msg)) v1 = Int32FromInt32(0) @@ -124954,33 +124954,33 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { _2: ; if uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len) < uint64(16) || (uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+uint64(8)-uint64(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))+uint64(16) >= Uint64FromInt64(int64((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_control+uintptr((*Tmsghdr)(unsafe.Pointer(bp+96)).Fmsg_controllen))-int64(c1)) { - v4 = uintptr(0) + v3 = uintptr(0) } else { - v4 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) + v3 = c1 + uintptr((uint64((*Tcmsghdr)(unsafe.Pointer(c1)).Fcmsg_len)+Uint64FromInt64(8)-Uint64FromInt32(1))&Uint64FromInt64(^Int64FromUint64(Uint64FromInt64(8)-Uint64FromInt32(1)))) } - c1 = v4 + c1 = v3 } } } - v5 = int32(SYS_sendmsg) - v6 = int32(__SC_sendmsg) - v7 = int32(1) + v1 = int32(SYS_sendmsg) + v5 = int32(__SC_sendmsg) + v6 = int32(1) v8 = int64(fd) v9 = int64(msg) v10 = int64(flags) v11 = int64(Int32FromInt32(0)) v12 = int64(Int32FromInt32(0)) v13 = int64(Int32FromInt32(0)) - if v7 != 0 { - r = ___syscall_cp(tls, int64(v5), v8, v9, v10, v11, v12, v13) + if v6 != 0 { + r = ___syscall_cp(tls, int64(v1), v8, v9, v10, v11, v12, v13) } else { - r = X__syscall6(tls, int64(v5), v8, v9, v10, v11, v12, v13) + r = X__syscall6(tls, int64(v1), v8, v9, v10, v11, v12, v13) } if r != int64(-Int32FromInt32(ENOSYS)) { v14 = r goto _15 } - if v7 != 0 { + if v6 != 0 { *(*[6]int64)(unsafe.Pointer(bp)) = [6]int64{ 0: v8, 1: v9, @@ -124989,7 +124989,7 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { 4: v12, 5: v13, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v6), int64(bp), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v5), int64(bp), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 48)) = [6]int64{ 0: v8, @@ -124999,7 +124999,7 @@ func Xsendmsg(tls *TLS, fd int32, msg uintptr, flags int32) (r1 Tssize_t) { 4: v12, 5: v13, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v6), int64(bp+48)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v5), int64(bp+48)) } v14 = r goto _15 @@ -125090,14 +125090,14 @@ func Xsetsockopt(tls *TLS, fd int32, level int32, optname int32, optval uintptr, } bp := tls.Alloc(304) defer tls.Free(304) - var r, v10, v22, v33 int64 - var r1, v1, v13, v14, v15, v2, v24, v25, v26, v3 int32 + var r, v10 int64 + var r1, v1, v2, v3 int32 var s Ttime_t var tv uintptr var us Tsuseconds_t var v12 uint64 - var v16, v17, v18, v19, v20, v21, v27, v28, v29, v30, v31, v32, v4, v5, v6, v7, v8, v9 Tsyscall_arg_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v13, v14, v15, v16, v17, v18, v19, v2, v20, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v4, v5, v6, v7, v8, v9 + var v4, v5, v6, v7, v8, v9 Tsyscall_arg_t + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = r, r1, s, tv, us, v1, v10, v12, v2, v3, v4, v5, v6, v7, v8, v9 v1 = int32(SYS_setsockopt) v2 = int32(__SC_setsockopt) v3 = 0 @@ -125175,49 +125175,49 @@ _11: 0: s, 1: int64(Int32FromUint64(v12)), } - v13 = int32(SYS_setsockopt) - v14 = int32(__SC_setsockopt) - v15 = 0 - v16 = int64(fd) - v17 = int64(level) - v18 = int64(optname) - v19 = int64(bp + 96) - v20 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) - v21 = int64(Int32FromInt32(0)) - if v15 != 0 { - r = ___syscall_cp(tls, int64(v13), v16, v17, v18, v19, v20, v21) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(bp + 96) + v8 = Int64FromUint64(Uint64FromInt32(2) * Uint64FromInt64(8)) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v13), v16, v17, v18, v19, v20, v21) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v22 = r + v10 = r goto _23 } - if v15 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 208)) = [6]int64{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v14), int64(bp+208), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+208), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 256)) = [6]int64{ - 0: v16, - 1: v17, - 2: v18, - 3: v19, - 4: v20, - 5: v21, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v14), int64(bp+256)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+256)) } - v22 = r + v10 = r goto _23 _23: - r1 = int32(v22) + r1 = int32(v10) case int32(SO_TIMESTAMP): fallthrough case int32(SO_TIMESTAMPNS): @@ -125230,49 +125230,49 @@ _11: if optname == int32(SO_TIMESTAMPNS) { optname = int32(SO_TIMESTAMPNS_OLD) } - v24 = int32(SYS_setsockopt) - v25 = int32(__SC_setsockopt) - v26 = 0 - v27 = int64(fd) - v28 = int64(level) - v29 = int64(optname) - v30 = int64(optval) - v31 = Int64FromUint32(optlen) - v32 = int64(Int32FromInt32(0)) - if v26 != 0 { - r = ___syscall_cp(tls, int64(v24), v27, v28, v29, v30, v31, v32) + v1 = int32(SYS_setsockopt) + v2 = int32(__SC_setsockopt) + v3 = 0 + v4 = int64(fd) + v5 = int64(level) + v6 = int64(optname) + v7 = int64(optval) + v8 = Int64FromUint32(optlen) + v9 = int64(Int32FromInt32(0)) + if v3 != 0 { + r = ___syscall_cp(tls, int64(v1), v4, v5, v6, v7, v8, v9) } else { - r = X__syscall6(tls, int64(v24), v27, v28, v29, v30, v31, v32) + r = X__syscall6(tls, int64(v1), v4, v5, v6, v7, v8, v9) } if r != int64(-Int32FromInt32(ENOSYS)) { - v33 = r + v10 = r goto _34 } - if v26 != 0 { + if v3 != 0 { *(*[6]int64)(unsafe.Pointer(bp + 208)) = [6]int64{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v25), int64(bp+208), 0, 0, 0, 0) + r = ___syscall_cp(tls, int64(SYS_socketcall), int64(v2), int64(bp+208), 0, 0, 0, 0) } else { *(*[6]int64)(unsafe.Pointer(bp + 256)) = [6]int64{ - 0: v27, - 1: v28, - 2: v29, - 3: v30, - 4: v31, - 5: v32, + 0: v4, + 1: v5, + 2: v6, + 3: v7, + 4: v8, + 5: v9, } - r = X__syscall2(tls, int64(SYS_socketcall), int64(v25), int64(bp+256)) + r = X__syscall2(tls, int64(SYS_socketcall), int64(v2), int64(bp+256)) } - v33 = r + v10 = r goto _34 _34: - r1 = int32(v33) + r1 = int32(v10) break } } @@ -125668,18 +125668,18 @@ const REQVERSION = 0 const REQ_LEN = 3 func _itoa1(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -125694,14 +125694,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz var f, key, ptr, tmp, tmp1 uintptr var grlist_len, len1 Tsize_t var i, req, v10 Tint32_t - var rv, v1, v2, v4, v8 int32 + var rv, v1 int32 var v5, v6 Tuint32_t var _ /* cs at bp+0 */ int32 var _ /* gidbuf at bp+28 */ [11]uint8 var _ /* groupbuf at bp+4 */ [6]Tint32_t var _ /* name_len at bp+44 */ Tuint32_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v2, v4, v5, v6, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, grlist_len, i, key, len1, ptr, req, rv, tmp, tmp1, v1, v10, v5, v6 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp) @@ -125723,11 +125723,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = int32(GETGRBYNAME) + v1 = int32(GETGRBYNAME) } else { - v2 = int32(GETGRBYGID) + v1 = int32(GETGRBYGID) } - req = v2 + req = v1 *(*[6]Tint32_t)(unsafe.Pointer(bp + 4)) = [6]Tint32_t{} len1 = uint64(0) grlist_len = uint64(0) @@ -125767,11 +125767,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if Xfread(tls, bp+44, uint64(4), uint64(1), f) < uint64(1) { if Xferror(tls, f) != 0 { - v4 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v4 = int32(EIO) + v1 = int32(EIO) } - rv = v4 + rv = v1 goto cleanup_f } if *(*int32)(unsafe.Pointer(bp + 40)) != 0 { @@ -125785,12 +125785,12 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz rv = int32(ENOMEM) goto cleanup_f } - len1 += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) - grlist_len += uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + len1 = len1 + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) + grlist_len = grlist_len + uint64(*(*Tuint32_t)(unsafe.Pointer(bp + 44))) goto _3 _3: ; - i++ + i = i + 1 } if len1 > *(*Tsize_t)(unsafe.Pointer(size)) || !(*(*uintptr)(unsafe.Pointer(buf)) != 0) { tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(buf)), len1) @@ -125803,11 +125803,11 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v8 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v8 = int32(EIO) + v1 = int32(EIO) } - rv = v8 + rv = v1 goto cleanup_f } if Uint64FromInt32((*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)]+int32(1)) > *(*Tsize_t)(unsafe.Pointer(nmem)) { @@ -125832,14 +125832,14 @@ func X__getgr_a(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, siz break } if !(*(*uint8)(unsafe.Pointer(ptr)) != 0) { - i++ + i = i + 1 v10 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v10)*8)) = ptr + uintptr(1) } goto _9 _9: ; - ptr++ + ptr = ptr + 1 } *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(i)*8)) = uintptr(0) if i != (*(*[6]Tint32_t)(unsafe.Pointer(bp + 4)))[int32(GRMEMCNT)] { @@ -125901,9 +125901,9 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size rv = int32(ERANGE) } if *(*uintptr)(unsafe.Pointer(res)) != 0 { - buf += uintptr((uint64(16) - uint64(buf)) % uint64(16)) + buf = buf + uintptr((uint64(16)-uint64(buf))%uint64(16)) (*Tgroup)(unsafe.Pointer(gr)).Fgr_mem = buf - buf += uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24)) + uint64(1)) * uint64(8)) + buf = buf + uintptr((*(*Tsize_t)(unsafe.Pointer(bp + 24))+uint64(1))*uint64(8)) Xmemcpy(tls, buf, *(*uintptr)(unsafe.Pointer(bp)), *(*Tsize_t)(unsafe.Pointer(bp + 8))) (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_name)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = uintptr(int64((*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd)-int64(*(*uintptr)(unsafe.Pointer(bp)))) + buf @@ -125916,7 +125916,7 @@ func _getgr_r(tls *TLS, name uintptr, gid Tgid_t, gr uintptr, buf uintptr, size goto _1 _1: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tgroup)(unsafe.Pointer(gr)).Fgr_mem + uintptr(i)*8)) = uintptr(0) } @@ -126033,7 +126033,7 @@ func _atou(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126045,13 +126045,13 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, } bp := tls.Alloc(16) defer tls.Free(16) - var i, v13, v14 Tsize_t + var i, v13 Tsize_t var l, v2 Tssize_t - var mems, v12, v4, v5, v6, v7, v8, v9 uintptr + var mems, v4 uintptr var rv, v3 int32 var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, mems, rv, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _ = i, l, mems, rv, v13, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126072,32 +126072,32 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tgroup)(unsafe.Pointer(gr)).Fgr_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tgroup)(unsafe.Pointer(gr)).Fgr_gid = _atou(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) mems = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126109,12 +126109,12 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - *(*Tsize_t)(unsafe.Pointer(nmem))++ + *(*Tsize_t)(unsafe.Pointer(nmem)) = *(*Tsize_t)(unsafe.Pointer(nmem)) + 1 } goto _10 _10: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } Xfree(tls, *(*uintptr)(unsafe.Pointer(mem))) *(*uintptr)(unsafe.Pointer(mem)) = Xcalloc(tls, uint64(8), *(*Tsize_t)(unsafe.Pointer(nmem))+uint64(1)) @@ -126134,21 +126134,21 @@ func X__getgrent_a(tls *TLS, f uintptr, gr uintptr, line uintptr, size uintptr, break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32(',') { - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) - i++ + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + i = i + 1 v13 = i *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = *(*uintptr)(unsafe.Pointer(bp)) } goto _11 _11: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } - i++ - v14 = i - *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v14)*8)) = uintptr(0) + i = i + 1 + v13 = i + *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)) + uintptr(v13)*8)) = uintptr(0) } else { *(*uintptr)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(mem)))) = uintptr(0) } @@ -126171,8 +126171,8 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u } bp := tls.Alloc(96) defer tls.Free(96) - var f, nscdbuf, v1, v10, v13 uintptr - var i, n, v12, v9 Tssize_t + var f, nscdbuf, v1 uintptr + var i, n, v9 Tssize_t var nbytes Tsize_t var nlim, ret, rv, v6 int32 var v14 int64 @@ -126185,7 +126185,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u var _ /* resp at bp+44 */ [3]Tint32_t var _ /* size at bp+80 */ Tsize_t var _ /* swap at bp+40 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v10, v12, v13, v14, v3, v4, v6, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = f, i, n, nbytes, nlim, nscdbuf, ret, rv, v1, v14, v3, v4, v6, v9 ret = -int32(1) n = int64(1) *(*int32)(unsafe.Pointer(bp + 40)) = 0 @@ -126229,7 +126229,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _2 _2: ; - i++ + i = i + 1 } } } @@ -126257,7 +126257,7 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _7 _7: ; - i++ + i = i + 1 } } i = 0 @@ -126268,17 +126268,17 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u goto _8 _8: ; - i++ + i = i + 1 } if !(*(*uintptr)(unsafe.Pointer((*(*Tgroup)(unsafe.Pointer(bp))).Fgr_mem + uintptr(i)*8)) != 0) { continue } - n++ + n = n + 1 v9 = n if v9 <= int64(nlim) { - v10 = groups + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v10)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid + *(*Tgid_t)(unsafe.Pointer(v1)) = (*(*Tgroup)(unsafe.Pointer(bp))).Fgr_gid } } if rv != 0 { @@ -126293,18 +126293,18 @@ func Xgetgrouplist(tls *TLS, user uintptr, gid Tgid_t, groups uintptr, ngroups u break } if *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) != gid { - n++ - v12 = n - if v12 <= int64(nlim) { - v13 = groups + n = n + 1 + v9 = n + if v9 <= int64(nlim) { + v1 = groups groups += 4 - *(*Tgid_t)(unsafe.Pointer(v13)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) + *(*Tgid_t)(unsafe.Pointer(v1)) = *(*Tuint32_t)(unsafe.Pointer(nscdbuf + uintptr(i)*4)) } } goto _11 _11: ; - i++ + i = i + 1 } } if n > int64(nlim) { @@ -126327,18 +126327,18 @@ cleanup: } func _itoa2(tls *TLS, p uintptr, x Tuint32_t) (r uintptr) { - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 // number of digits in a uint32_t + NUL - p += uintptr(11) - p-- + p = p + uintptr(11) + p = p - 1 v1 = p *(*uint8)(unsafe.Pointer(v1)) = uint8(0) for cond := true; cond; cond = x != 0 { - p-- - v2 = p - *(*uint8)(unsafe.Pointer(v2)) = uint8(uint32('0') + x%uint32(10)) - x /= uint32(10) + p = p - 1 + v1 = p + *(*uint8)(unsafe.Pointer(v1)) = uint8(uint32('0') + x%uint32(10)) + x = x / uint32(10) } return p } @@ -126353,11 +126353,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz var f, key, tmp uintptr var len1 Tsize_t var req Tint32_t - var rv, v1, v2, v3 int32 + var rv, v1 int32 var _ /* cs at bp+4 */ int32 var _ /* passwdbuf at bp+8 */ [9]Tint32_t var _ /* uidbuf at bp+44 */ [11]uint8 - _, _, _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1, v2, v3 + _, _, _, _, _, _, _ = f, key, len1, req, rv, tmp, v1 rv = 0 *(*uintptr)(unsafe.Pointer(res)) = uintptr(0) _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+4) @@ -126379,11 +126379,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz Xfclose(tls, f) if !(*(*uintptr)(unsafe.Pointer(res)) != 0) && (rv == 0 || rv == int32(ENOENT) || rv == int32(ENOTDIR)) { if name != 0 { - v2 = GETPWBYNAME + v1 = GETPWBYNAME } else { - v2 = int32(GETPWBYUID) + v1 = int32(GETPWBYUID) } - req = v2 + req = v1 *(*[9]Tint32_t)(unsafe.Pointer(bp + 8)) = [9]Tint32_t{} len1 = uint64(0) *(*[11]uint8)(unsafe.Pointer(bp + 44)) = [11]uint8{} @@ -126435,11 +126435,11 @@ func X__getpw_a(tls *TLS, name uintptr, uid Tuid_t, pw uintptr, buf uintptr, siz } if !(Xfread(tls, *(*uintptr)(unsafe.Pointer(buf)), len1, uint64(1), f) != 0) { if Xferror(tls, f) != 0 { - v3 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) + v1 = *(*int32)(unsafe.Pointer(X__errno_location(tls))) } else { - v3 = int32(EIO) + v1 = int32(EIO) } - rv = v3 + rv = v1 goto cleanup_f } (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = *(*uintptr)(unsafe.Pointer(buf)) @@ -126603,7 +126603,7 @@ func _atou1(tls *TLS, s uintptr) (r uint32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return x } @@ -126617,10 +126617,10 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, defer tls.Free(16) var l, v2 Tssize_t var rv, v3 int32 - var v10, v11, v12, v13, v14, v4, v5, v6, v7, v8, v9 uintptr + var v4 uintptr var _ /* cs at bp+8 */ int32 var _ /* s at bp+0 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = l, rv, v10, v11, v12, v13, v14, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _ = l, rv, v2, v3, v4 rv = 0 _pthread_setcancelstate(tls, int32(PTHREAD_CANCEL_DISABLE), bp+8) for { @@ -126641,57 +126641,57 @@ func X__getpwent_a(tls *TLS, f uintptr, pw uintptr, line uintptr, size uintptr, *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(line)) + uintptr(l-int64(1)))) = uint8(0) *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(line)) v4 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 (*Tpasswd)(unsafe.Pointer(pw)).Fpw_name = v4 - v5 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v5 - if !(v5 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v6 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v6)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_passwd = *(*uintptr)(unsafe.Pointer(bp)) - v7 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v7 - if !(v7 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v8)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_uid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v9 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v9)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gid = _atou1(tls, bp) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != int32(':') { goto _1 } - v10 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v10)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_gecos = *(*uintptr)(unsafe.Pointer(bp)) - v11 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v11 - if !(v11 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v12 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v12)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_dir = *(*uintptr)(unsafe.Pointer(bp)) - v13 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) - *(*uintptr)(unsafe.Pointer(bp)) = v13 - if !(v13 != 0) { + v4 = Xstrchr(tls, *(*uintptr)(unsafe.Pointer(bp)), int32(':')) + *(*uintptr)(unsafe.Pointer(bp)) = v4 + if !(v4 != 0) { goto _1 } - v14 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ - *(*uint8)(unsafe.Pointer(v14)) = uint8(0) + v4 = *(*uintptr)(unsafe.Pointer(bp)) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 + *(*uint8)(unsafe.Pointer(v4)) = uint8(0) (*Tpasswd)(unsafe.Pointer(pw)).Fpw_shell = *(*uintptr)(unsafe.Pointer(bp)) break goto _1 @@ -126759,10 +126759,10 @@ func X__nscd_query(tls *TLS, req Tint32_t, key uintptr, buf uintptr, len1 Tsize_ var errno_save, fd int32 var f, v1 uintptr var i Tsize_t - var v3, v4, v7, v8 Tuint32_t + var v3, v4 Tuint32_t var _ /* msg at bp+48 */ Tmsghdr var _ /* req_buf at bp+32 */ [3]Tint32_t - _, _, _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4, v7, v8 + _, _, _, _, _, _, _ = errno_save, f, fd, i, v1, v3, v4 f = uintptr(0) *(*[3]Tint32_t)(unsafe.Pointer(bp + 32)) = [3]Tint32_t{ 0: int32(NSCDVERSION), @@ -126848,7 +126848,7 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(swap)) = int32(1) goto retry @@ -126863,15 +126863,15 @@ retry: if !(i < len1/uint64(4)) { break } - v7 = Uint32FromInt32(*(*Tint32_t)(unsafe.Pointer(buf + uintptr(i)*4))) - v8 = v7>>int32(24) | v7>>int32(8)&uint32(0xff00) | v7<>int32(24) | v3>>int32(8)&uint32(0xff00) | v3<> int32(11) - x ^= x << int32(7) & uint32(0x9D2C5680) - x ^= x << int32(15) & uint32(0xEFC60000) - x ^= x >> int32(18) + x = x ^ x>>int32(11) + x = x ^ x<>int32(18) return x } @@ -127274,7 +127274,7 @@ func ___srandom(tls *TLS, seed uint32) { goto _2 _2: ; - k++ + k = k + 1 } /* make sure x contains at least one odd number */ *(*Tuint32_t)(unsafe.Pointer(_x1)) |= uint32(1) @@ -127346,8 +127346,8 @@ func Xrandom(tls *TLS) (r int64) { } var k int64 var v1 Tuint32_t - var v2, v3 int32 - _, _, _, _ = k, v1, v2, v3 + var v2 int32 + _, _, _ = k, v1, v2 ___lock(tls, uintptr(unsafe.Pointer(&_lock3))) if _n == 0 { v1 = _lcg31(tls, *(*Tuint32_t)(unsafe.Pointer(_x1))) @@ -127357,14 +127357,14 @@ func Xrandom(tls *TLS) (r int64) { } *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) += *(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_j)*4)) k = Int64FromUint32(*(*Tuint32_t)(unsafe.Pointer(_x1 + uintptr(_i)*4)) >> int32(1)) - _i++ + _i = _i + 1 v2 = _i if v2 == _n { _i = 0 } - _j++ - v3 = _j - if v3 == _n { + _j = _j + 1 + v2 = _j + if v2 == _n { _j = 0 } goto end @@ -127420,7 +127420,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127436,7 +127436,7 @@ func Xexecl(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127464,7 +127464,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127480,7 +127480,7 @@ func Xexecle(tls *TLS, path uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } envp = VaUintptr(&ap) _ = ap @@ -127508,7 +127508,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _1 _1: ; - argc++ + argc = argc + 1 } _ = ap v2 = Uint64FromInt32(argc+int32(1)) * 8 @@ -127524,7 +127524,7 @@ func Xexeclp(tls *TLS, file uintptr, argv0 uintptr, va uintptr) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } *(*uintptr)(unsafe.Add(unsafe.Pointer(argv), i*8)) = UintptrFromInt32(0) _ = ap @@ -127554,11 +127554,11 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { trc("tls=%v file=%v argv=%v envp=%v, (%v:)", tls, file, argv, envp, origin(2)) defer func() { trc("-> %v", r) }() } - var b, p, path, z, v3, v4 uintptr + var b, p, path, z, v3 uintptr var k, l Tsize_t var seen_eacces int32 var v2 t__predefined_size_t - _, _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = b, k, l, p, path, seen_eacces, z, v2, v3 defer func() { Xrealloc(tls, b, 0) }() path = Xgetenv(tls, __ccgo_ts+1391) seen_eacces = 0 @@ -127585,7 +127585,7 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { z = X__strchrnul(tls, p, int32(':')) if Uint64FromInt64(int64(z)-int64(p)) >= l { v3 = z - z++ + z = z + 1 if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } @@ -127605,9 +127605,9 @@ func X__execvpe(tls *TLS, file uintptr, argv uintptr, envp uintptr) (r int32) { default: return -int32(1) } - v4 = z - z++ - if !(*(*uint8)(unsafe.Pointer(v4)) != 0) { + v3 = z + z = z + 1 + if !(*(*uint8)(unsafe.Pointer(v3)) != 0) { break } goto _1 @@ -128090,7 +128090,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('\\') && *(*uint8)(unsafe.Pointer(pat + 1)) != 0 && !(flags&Int32FromInt32(FNM_NOESCAPE) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(2) - pat++ + pat = pat + 1 esc = int32(1) goto escaped } @@ -128098,12 +128098,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i k = uint64(1) if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('!') { - k++ + k = k + 1 } } if k < m { if Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32(']') { - k++ + k = k + 1 } } for { @@ -128112,12 +128112,12 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i } if k+uint64(1) < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1)))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) == int32('=')) { z = Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k+uint64(1))))) - k += uint64(2) + k = k + uint64(2) if k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 { - k++ + k = k + 1 } for k < m && *(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0 && (Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k-uint64(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(pat + uintptr(k)))) != int32(']')) { - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { break @@ -128126,7 +128126,7 @@ func _pat_next(tls *TLS, pat uintptr, m Tsize_t, step uintptr, flags int32) (r i goto _1 _1: ; - k++ + k = k + 1 } if k == m || !(*(*uint8)(unsafe.Pointer(pat + uintptr(k))) != 0) { *(*Tsize_t)(unsafe.Pointer(step)) = uint64(1) @@ -128179,22 +128179,22 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { var _ /* wc2 at bp+4 */ Twchar_t _, _, _, _, _ = inv, l, l1, p0, z inv = 0 - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('^') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('!') { inv = int32(1) - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { if k == int32(']') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { if k == int32('-') { return BoolInt32(!(inv != 0)) } - p++ + p = p + 1 } } *(*Twchar_t)(unsafe.Pointer(bp)) = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) @@ -128212,15 +128212,15 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { return BoolInt32(!(inv != 0)) } } - p += uintptr(l - int32(1)) + p = p + uintptr(l-int32(1)) goto _1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('[') && (Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32(':') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('.') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('=')) { p0 = p + uintptr(2) z = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - p += uintptr(3) + p = p + uintptr(3) for Int32FromUint8(*(*uint8)(unsafe.Pointer(p + uintptr(-Int32FromInt32(1))))) != z || Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32(']') { - p++ + p = p + 1 } if z == int32(':') && int64(p-uintptr(1))-int64(p0) < int64(16) { Xmemcpy(tls, bp+8, p0, Uint64FromInt64(int64(p-uintptr(1))-int64(p0))) @@ -128238,7 +128238,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { if l1 < 0 { return 0 } - p += uintptr(l1 - int32(1)) + p = p + uintptr(l1-int32(1)) } if *(*Twchar_t)(unsafe.Pointer(bp)) == k || *(*Twchar_t)(unsafe.Pointer(bp)) == kfold { return BoolInt32(!(inv != 0)) @@ -128246,7 +128246,7 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { goto _1 _1: ; - p++ + p = p + 1 } return inv } @@ -128254,13 +128254,13 @@ func _match_bracket(tls *TLS, p uintptr, k int32, kfold int32) (r int32) { func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, flags int32) (r int32) { bp := tls.Alloc(16) defer tls.Free(16) - var c, k, kfold, v12, v13, v15, v2, v3, v4, v8 int32 - var endpat, endstr, p, ptail, s, stail, v10, v6 uintptr + var c, k, kfold, v2 int32 + var endpat, endstr, p, ptail, s, stail, v6 uintptr var tailcnt Tsize_t var v9 bool var _ /* pinc at bp+0 */ Tsize_t var _ /* sinc at bp+8 */ Tsize_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v10, v12, v13, v15, v2, v3, v4, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _ = c, endpat, endstr, k, kfold, p, ptail, s, stail, tailcnt, v2, v6, v9 tailcnt = uint64(0) if flags&int32(FNM_PERIOD) != 0 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(str))) == int32('.') && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) != int32('.') { @@ -128274,26 +128274,26 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, case -int32(2): return int32(FNM_NOMATCH) case -int32(5): - pat++ - m-- + pat = pat + 1 + m = m - 1 default: k = _str_next(tls, str, n, bp+8) if k <= 0 { if c == END { - v3 = 0 + v2 = 0 } else { - v3 = int32(FNM_NOMATCH) + v2 = int32(FNM_NOMATCH) } - return v3 + return v2 } - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) - n -= *(*Tsize_t)(unsafe.Pointer(bp + 8)) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + n = n - *(*Tsize_t)(unsafe.Pointer(bp + 8)) if flags&int32(FNM_CASEFOLD) != 0 { - v4 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v4 = k + v2 = k } - kfold = v4 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, pat, k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128303,8 +128303,8 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } } - pat += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - m -= *(*Tsize_t)(unsafe.Pointer(bp)) + pat = pat + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + m = m - *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 } break @@ -128329,13 +128329,13 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, tailcnt = uint64(0) ptail = p + uintptr(1) default: - tailcnt++ + tailcnt = tailcnt + 1 break } goto _5 _5: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } /* Past this point we need not check for UNMATCHABLE in pat, * because all of pat has already been parsed once. */ @@ -128355,18 +128355,18 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, } if v9 = uint32(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) < uint32(128); !v9 { if !!(*(*uintptr)(unsafe.Pointer((*t__pthread)(unsafe.Pointer(uintptr(___get_tp(tls)))).Flocale)) != 0) { - v8 = int32(4) + v2 = int32(4) } else { - v8 = int32(1) + v2 = int32(1) } } - if v9 || v8 == int32(1) { - s-- + if v9 || v2 == int32(1) { + s = s - 1 } else { for { - s-- - v10 = s - if !(uint32(*(*uint8)(unsafe.Pointer(v10)))-uint32(0x80) < uint32(0x40) && s > str) { + s = s - 1 + v6 = s + if !(uint32(*(*uint8)(unsafe.Pointer(v6)))-uint32(0x80) < uint32(0x40) && s > str) { break } } @@ -128374,7 +128374,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _7 _7: ; - tailcnt-- + tailcnt = tailcnt - 1 } if tailcnt != 0 { return int32(FNM_NOMATCH) @@ -128384,22 +128384,22 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, p = ptail for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) - v12 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) - k = v12 - if v12 <= 0 { + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + v2 = _str_next(tls, s, Uint64FromInt64(int64(endstr)-int64(s)), bp+8) + k = v2 + if v2 <= 0 { if c != END { return int32(FNM_NOMATCH) } break } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) if flags&int32(FNM_CASEFOLD) != 0 { - v13 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v13 = k + v2 = k } - kfold = v13 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { return int32(FNM_NOMATCH) @@ -128421,7 +128421,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, s = str for { c = _pat_next(tls, p, Uint64FromInt64(int64(endpat)-int64(p)), bp, flags) - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) /* Encountering * completes/commits a component */ if c == -int32(5) { pat = p @@ -128433,11 +128433,11 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, return int32(FNM_NOMATCH) } if flags&int32(FNM_CASEFOLD) != 0 { - v15 = _casefold(tls, k) + v2 = _casefold(tls, k) } else { - v15 = k + v2 = k } - kfold = v15 + kfold = v2 if c == -int32(3) { if !(_match_bracket(tls, p-uintptr(*(*Tsize_t)(unsafe.Pointer(bp))), k, kfold) != 0) { break @@ -128447,7 +128447,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, break } } - s += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + s = s + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) goto _14 _14: } @@ -128458,9 +128458,9 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, * char, or past all invalid bytes otherwise. */ k = _str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) if k > 0 { - str += uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) + str = str + uintptr(*(*Tsize_t)(unsafe.Pointer(bp + 8))) } else { - str++ + str = str + 1 for { if !(_str_next(tls, str, Uint64FromInt64(int64(endstr)-int64(str)), bp+8) < 0) { break @@ -128468,7 +128468,7 @@ func _fnmatch_internal(tls *TLS, pat uintptr, m Tsize_t, str uintptr, n Tsize_t, goto _16 _16: ; - str++ + str = str + 1 } } } @@ -128496,7 +128496,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _2 _2: ; - s++ + s = s + 1 } p = pat for { @@ -128508,7 +128508,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _3 _3: ; - p += uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) + p = p + uintptr(*(*Tsize_t)(unsafe.Pointer(bp))) } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) && (!(*(*uint8)(unsafe.Pointer(s)) != 0) || !(flags&Int32FromInt32(FNM_LEADING_DIR) != 0)) { return int32(FNM_NOMATCH) @@ -128540,7 +128540,7 @@ func Xfnmatch(tls *TLS, pat uintptr, str uintptr, flags int32) (r int32) { goto _5 _5: ; - s++ + s = s + 1 } } } @@ -128595,13 +128595,13 @@ func _append(tls *TLS, tail uintptr, name uintptr, len1 Tsize_t, mark int32) (r func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, tail uintptr) (r1 int32) { bp := tls.Alloc(144) defer tls.Free(144) - var de, dir, p, p2, v11, v2, v7, v8 uintptr + var de, dir, p, p2, v2 uintptr var fnm_flags, in_bracket, old_errno, overflow, r, readerr, v10, v9 int32 - var i, j, v4, v5 Tptrdiff_t + var i, j, v4 Tptrdiff_t var l, v1 Tsize_t var saved_sep uint8 var _ /* st at bp+0 */ Tstat - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v11, v2, v4, v5, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = de, dir, fnm_flags, i, in_bracket, j, l, old_errno, overflow, p, p2, r, readerr, saved_sep, v1, v10, v2, v4, v9 /* If GLOB_MARK is unused, we don't care about type. */ if !(type1 != 0) && !(flags&Int32FromInt32(GLOB_MARK) != 0) { type1 = int32(DT_REG) @@ -128613,9 +128613,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag } for pos+uint64(1) < uint64(PATH_MAX) && Int32FromUint8(*(*uint8)(unsafe.Pointer(pat))) == int32('/') { v1 = pos - pos++ + pos = pos + 1 v2 = pat - pat++ + pat = pat + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) } /* Consume maximal [escaped-]literal prefix of pattern, copying @@ -128632,8 +128632,8 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if overflow != 0 { return 0 } - pat += uintptr(i) - pos += Uint64FromInt64(j) + pat = pat + uintptr(i) + pos = pos + Uint64FromInt64(j) v4 = Int64FromInt32(0) j = v4 i = v4 @@ -128653,7 +128653,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag if !(*(*uint8)(unsafe.Pointer(pat + uintptr(i+int64(1)))) != 0) { return 0 } - i++ + i = i + 1 } } } @@ -128662,9 +128662,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag return 0 } in_bracket = 0 - pat += uintptr(i + int64(1)) + pat = pat + uintptr(i+int64(1)) i = int64(-int32(1)) - pos += Uint64FromInt64(j + int64(1)) + pos = pos + Uint64FromInt64(j+int64(1)) j = int64(-int32(1)) } /* Only store a character if it fits in the buffer, but if @@ -128673,9 +128673,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag * is unterminated (and thereby a literal), so as not to * disallow long bracket expressions with short matches. */ if pos+Uint64FromInt64(j+Int64FromInt32(1)) < uint64(PATH_MAX) { - v5 = j - j++ - *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v5)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) + v4 = j + j = j + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(pos+Uint64FromInt64(v4)))) = *(*uint8)(unsafe.Pointer(pat + uintptr(i))) } else { if in_bracket != 0 { overflow = int32(1) @@ -128689,7 +128689,7 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _3 _3: ; - i++ + i = i + 1 } *(*uint8)(unsafe.Pointer(buf + uintptr(pos))) = uint8(0) if !(*(*uint8)(unsafe.Pointer(pat)) != 0) { @@ -128724,19 +128724,19 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag goto _6 _6: ; - p-- + p = p - 1 } if (int64(p2)-int64(p))%int64(2) != 0 { - p2-- + p2 = p2 - 1 saved_sep = uint8('\\') } } if pos != 0 { - v7 = buf + v2 = buf } else { - v7 = __ccgo_ts + 598 + v2 = __ccgo_ts + 598 } - dir = Xopendir(tls, v7) + dir = Xopendir(tls, v2) if !(dir != 0) { if (*(*func(*TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_errfunc})))(tls, buf, *(*int32)(unsafe.Pointer(X__errno_location(tls)))) != 0 || flags&int32(GLOB_ERR) != 0 { return int32(GLOB_ABORTED) @@ -128746,9 +128746,9 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag old_errno = *(*int32)(unsafe.Pointer(X__errno_location(tls))) for { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = 0 - v8 = Xreaddir(tls, dir) - de = v8 - if !(v8 != 0) { + v2 = Xreaddir(tls, dir) + de = v2 + if !(v2 != 0) { break } /* Quickly skip non-directories when there's pattern left. */ @@ -128786,11 +128786,11 @@ func _do_glob(tls *TLS, buf uintptr, pos Tsize_t, type1 int32, pat uintptr, flag *(*uint8)(unsafe.Pointer(p2)) = saved_sep } if p2 != 0 { - v11 = p2 + v2 = p2 } else { - v11 = __ccgo_ts + v2 = __ccgo_ts } - r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v11, flags, __ccgo_fp_errfunc, tail) + r = _do_glob(tls, buf, pos+l, Int32FromUint8((*Tdirent)(unsafe.Pointer(de)).Fd_type), v2, flags, __ccgo_fp_errfunc, tail) if r != 0 { Xclosedir(tls, dir) return r @@ -128836,13 +128836,13 @@ func _sort(tls *TLS, a uintptr, b uintptr) (r int32) { func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var delim, v1, v12 uint8 - var home, name_end, p, v11, v2, v3 uintptr - var i, v10, v13 Tsize_t + var delim, v1 uint8 + var home, name_end, p, v2 uintptr + var i, v10 Tsize_t var v4 int32 var _ /* pw at bp+0 */ Tpasswd var _ /* res at bp+48 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v11, v12, v13, v2, v3, v4 + _, _, _, _, _, _, _, _, _ = delim, home, i, name_end, p, v1, v10, v2, v4 p = *(*uintptr)(unsafe.Pointer(pat)) + uintptr(1) i = uint64(0) name_end = X__strchrnul(tls, p, int32('/')) @@ -128850,16 +128850,16 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { delim = v1 if v1 != 0 { v2 = name_end - name_end++ + name_end = name_end + 1 *(*uint8)(unsafe.Pointer(v2)) = uint8(0) } *(*uintptr)(unsafe.Pointer(pat)) = name_end if *(*uint8)(unsafe.Pointer(p)) != 0 { - v3 = UintptrFromInt32(0) + v2 = UintptrFromInt32(0) } else { - v3 = Xgetenv(tls, __ccgo_ts+1425) + v2 = Xgetenv(tls, __ccgo_ts+1425) } - home = v3 + home = v2 if !(home != 0) { if *(*uint8)(unsafe.Pointer(p)) != 0 { v4 = Xgetpwnam_r(tls, p, bp, buf, uint64(PATH_MAX), bp+48) @@ -128894,20 +128894,20 @@ func _expand_tilde(tls *TLS, pat uintptr, buf uintptr, pos uintptr) (r int32) { } for i < Uint64FromInt32(Int32FromInt32(PATH_MAX)-Int32FromInt32(2)) && *(*uint8)(unsafe.Pointer(home)) != 0 { v10 = i - i++ - v11 = home - home++ - *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v11)) + i = i + 1 + v2 = home + home = home + 1 + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = *(*uint8)(unsafe.Pointer(v2)) } if *(*uint8)(unsafe.Pointer(home)) != 0 { return int32(GLOB_NOMATCH) } - v12 = delim - *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v12 - if v12 != 0 { - i++ - v13 = i - *(*uint8)(unsafe.Pointer(buf + uintptr(v13))) = uint8(0) + v1 = delim + *(*uint8)(unsafe.Pointer(buf + uintptr(i))) = v1 + if v1 != 0 { + i = i + 1 + v10 = i + *(*uint8)(unsafe.Pointer(buf + uintptr(v10))) = uint8(0) } *(*Tsize_t)(unsafe.Pointer(pos)) = i return 0 @@ -128981,7 +128981,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _2: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - cnt++ + cnt = cnt + 1 } if !(cnt != 0) { if flags&int32(GLOB_NOCHECK) != 0 { @@ -128989,7 +128989,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint if _append(tls, bp+8, pat, Xstrlen(tls, pat), 0) != 0 { return int32(GLOB_NOSPACE) } - cnt++ + cnt = cnt + 1 } else { if !(error1 != 0) { return int32(GLOB_NOMATCH) @@ -129003,7 +129003,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint return int32(GLOB_NOSPACE) } (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = pathv - offs += (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc + offs = offs + (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc } else { (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv = Xmalloc(tls, (offs+cnt+uint64(1))*uint64(8)) if !((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv != 0) { @@ -129019,7 +129019,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint goto _3 _3: ; - i++ + i = i + 1 } } i = uint64(0) @@ -129033,7 +129033,7 @@ func Xglob(tls *TLS, pat uintptr, flags int32, __ccgo_fp_errfunc uintptr, g uint _4: ; *(*uintptr)(unsafe.Pointer(bp + 8)) = (*Tmatch)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))).Fnext - i++ + i = i + 1 } *(*uintptr)(unsafe.Pointer((*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv + uintptr(offs+i)*8)) = UintptrFromInt32(0) *(*Tsize_t)(unsafe.Pointer(g)) += cnt @@ -129058,7 +129058,7 @@ func Xglobfree(tls *TLS, g uintptr) { goto _1 _1: ; - i++ + i = i + 1 } Xfree(tls, (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathv) (*Tglob_t)(unsafe.Pointer(g)).Fgl_pathc = uint64(0) @@ -129454,7 +129454,7 @@ func _tre_stack_push(tls *TLS, s uintptr, value Ttre_stack_item) (r Treg_errcode _, _ = new_buffer, new_size if (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr < (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize { *(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr((*Ttre_stack_t)(unsafe.Pointer(s)).Fptr)*8)) = value - (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr++ + (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr = (*Ttre_stack_t)(unsafe.Pointer(s)).Fptr + 1 } else { if (*Ttre_stack_t)(unsafe.Pointer(s)).Fsize >= (*Ttre_stack_t)(unsafe.Pointer(s)).Fmax_size { return int32(REG_ESPACE) @@ -129495,7 +129495,7 @@ func _tre_stack_pop_int(tls *TLS, s uintptr) (r int32) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*int32)(unsafe.Pointer(&*(*Ttre_stack_item)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)))) } @@ -129505,7 +129505,7 @@ func _tre_stack_pop_voidptr(tls *TLS, s uintptr) (r uintptr) { var v2 uintptr _, _ = v1, v2 v2 = s + 12 - *(*int32)(unsafe.Pointer(v2))-- + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1 v1 = *(*int32)(unsafe.Pointer(v2)) return *(*uintptr)(unsafe.Pointer((*Ttre_stack_t)(unsafe.Pointer(s)).Fstack + uintptr(v1)*8)) } @@ -129603,7 +129603,7 @@ func _tre_expand_macro(tls *TLS, s uintptr) (r uintptr) { goto _1 _1: ; - i++ + i = i + 1 } return _tre_macros[i].Fexpansion } @@ -129641,16 +129641,16 @@ func _tre_new_lit(tls *TLS, p uintptr) (r uintptr) { } v2 = p + 16 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 a = (*Tliterals)(unsafe.Pointer(p)).Fa + uintptr(v1)*8 *(*uintptr)(unsafe.Pointer(a)) = X__tre_mem_alloc_impl(tls, (*Tliterals)(unsafe.Pointer(p)).Fmem, 0, UintptrFromInt32(0), int32(1), uint64(40)) return *(*uintptr)(unsafe.Pointer(a)) } func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { - var b, c, e, v2, v4 int32 + var b, c, e, v2 int32 var lit uintptr - _, _, _, _, _, _ = b, c, e, lit, v2, v4 + _, _, _, _, _ = b, c, e, lit, v2 c = min for { if !(c <= max) { @@ -129663,8 +129663,8 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { v2 = Int32FromUint32(Xtowupper(tls, Uint32FromInt32(c))) e = v2 b = v2 - c++ - e++ + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129675,16 +129675,16 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _3 _3: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { if Xiswupper(tls, Uint32FromInt32(c)) != 0 { - v4 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) - e = v4 - b = v4 - c++ - e++ + v2 = Int32FromUint32(Xtowlower(tls, Uint32FromInt32(c))) + e = v2 + b = v2 + c = c + 1 + e = e + 1 for { if !(c <= max) { break @@ -129695,11 +129695,11 @@ func _add_icase_literals(tls *TLS, ls uintptr, min int32, max int32) (r int32) { goto _5 _5: ; - c++ - e++ + c = c + 1 + e = e + 1 } } else { - c++ + c = c + 1 goto _1 } } @@ -129748,11 +129748,11 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint bp := tls.Alloc(32) defer tls.Free(32) var class Ttre_ctype_t - var len1, max, min, v2, v4, v5 int32 + var len1, max, min, v2 int32 var lit, start, v6 uintptr var _ /* tmp at bp+4 */ [15]uint8 var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v4, v5, v6 + _, _, _, _, _, _, _, _ = class, len1, lit, max, min, start, v2, v6 start = s for { class = uint64(0) @@ -129777,7 +129777,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ECOLLATE) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('[') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32(':') { - s += uintptr(2) + s = s + uintptr(2) len1 = 0 for { if !(len1 < int32(CHARCLASS_NAME_MAX) && *(*uint8)(unsafe.Pointer(s + uintptr(len1))) != 0) { @@ -129792,21 +129792,21 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint goto _3 _3: ; - len1++ + len1 = len1 + 1 } if !(class != 0) || Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(len1+int32(1))))) != int32(']') { return int32(REG_ECTYPE) } min = 0 max = int32(TRE_CHAR_MAX) - s += uintptr(len1 + int32(2)) + s = s + uintptr(len1+int32(2)) } else { - v4 = *(*Twchar_t)(unsafe.Pointer(bp)) - max = v4 - min = v4 - s += uintptr(len1) + v2 = *(*Twchar_t)(unsafe.Pointer(bp)) + max = v2 + min = v2 + s = s + uintptr(len1) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) != int32(']') { - s++ + s = s + 1 len1 = Xmbtowc(tls, bp, s, Uint64FromInt32(-Int32FromInt32(1))) max = *(*Twchar_t)(unsafe.Pointer(bp)) /* XXX - Should use collation order instead of @@ -129814,7 +129814,7 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint if len1 <= 0 || min > max { return int32(REG_ERANGE) } - s += uintptr(len1) + s = s + uintptr(len1) } } if class != 0 && (*Tneg)(unsafe.Pointer(neg)).Fnegate != 0 { @@ -129822,9 +129822,9 @@ func _parse_bracket_terms(tls *TLS, ctx uintptr, s uintptr, ls uintptr, neg uint return int32(REG_ESPACE) } v6 = neg + 4 - v5 = *(*int32)(unsafe.Pointer(v6)) - *(*int32)(unsafe.Pointer(v6))++ - *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v5)*8)) = class + v2 = *(*int32)(unsafe.Pointer(v6)) + *(*int32)(unsafe.Pointer(v6)) = *(*int32)(unsafe.Pointer(v6)) + 1 + *(*Ttre_ctype_t)(unsafe.Pointer(neg + 8 + uintptr(v2)*8)) = class } else { lit = _tre_new_lit(tls, ls) if !(lit != 0) { @@ -129857,11 +129857,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(544) defer tls.Free(544) var err Treg_errcode_t - var i, max, min, negmax, negmin, v1, v3 int32 + var i, max, min, negmax, negmin, v1 int32 var lit, n, nc, node uintptr var _ /* ls at bp+0 */ Tliterals var _ /* neg at bp+24 */ Tneg - _, _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1, v3 + _, _, _, _, _, _, _, _, _, _, _ = err, i, lit, max, min, n, nc, negmax, negmin, node, v1 node = uintptr(0) nc = uintptr(0) (*(*Tliterals)(unsafe.Pointer(bp))).Fmem = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem @@ -129874,7 +129874,7 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { (*(*Tneg)(unsafe.Pointer(bp + 24))).Flen1 = 0 (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('^')) if (*(*Tneg)(unsafe.Pointer(bp + 24))).Fnegate != 0 { - s++ + s = s + 1 } err = _parse_bracket_terms(tls, ctx, s, bp, bp+24) if err != REG_OK { @@ -129933,11 +129933,11 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { if min <= negmin { /* Overlap. */ if max+int32(1) >= negmin { - v3 = max + int32(1) + v1 = max + int32(1) } else { - v3 = negmin + v1 = negmin } - negmin = v3 + negmin = v1 goto _2 } negmax = min - int32(1) @@ -129956,13 +129956,13 @@ func _parse_bracket(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { goto _2 _2: ; - i++ + i = i + 1 } goto parse_bracket_done parse_bracket_done: ; Xfree(tls, (*(*Tliterals)(unsafe.Pointer(bp))).Fa) - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return err } @@ -129975,7 +129975,7 @@ func _parse_dup_count(tls *TLS, s uintptr, n uintptr) (r uintptr) { *(*int32)(unsafe.Pointer(n)) = 0 for { *(*int32)(unsafe.Pointer(n)) = int32(10)**(*int32)(unsafe.Pointer(n)) + (Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0')) - s++ + s = s + 1 if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) || *(*int32)(unsafe.Pointer(n)) > int32(RE_DUP_MAX) { break } @@ -130002,12 +130002,12 @@ func _parse_dup(tls *TLS, s uintptr, ere int32, pmin uintptr, pmax uintptr) (r u if v3 = *(*int32)(unsafe.Pointer(bp + 4)) < *(*int32)(unsafe.Pointer(bp)) && *(*int32)(unsafe.Pointer(bp + 4)) >= 0 || *(*int32)(unsafe.Pointer(bp + 4)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) > int32(RE_DUP_MAX) || *(*int32)(unsafe.Pointer(bp)) < 0; !v3 { if v2 = !(ere != 0); v2 { v1 = s - s++ + s = s + 1 } } if v5 = v3 || v2 && Int32FromUint8(*(*uint8)(unsafe.Pointer(v1))) != int32('\\'); !v5 { v4 = s - s++ + s = s + 1 } if v5 || Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) != int32('}') { return uintptr(0) @@ -130021,7 +130021,7 @@ func _hexval1(tls *TLS, c uint32) (r int32) { if c-uint32('0') < uint32(10) { return Int32FromUint32(c - uint32('0')) } - c |= uint32(32) + c = c | uint32(32) if c-uint32('a') < uint32(6) { return Int32FromUint32(c - uint32('a') + uint32(10)) } @@ -130044,7 +130044,7 @@ func _marksub(tls *TLS, ctx uintptr, node uintptr, subid int32) (r Treg_errcode_ node = n } (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id = subid - (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches++ + (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = node return REG_OK } @@ -130070,11 +130070,11 @@ Dup = '*' | '+' | '?' | '{' Count '}' | '{' Count ',}' | '{' Count func _parse_atom(tls *TLS, ctx uintptr, s uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, ere, i, len1, v, val, v16, v18, v20, v21, v23, v25 int32 + var c, ere, i, len1, v, val, v16 int32 var err Treg_errcode_t - var node, p, tmp1, tmp11, tmp2, tmp21, v14, v17, v19, v22, v24, v26 uintptr + var node, p, tmp1, tmp11, tmp2, tmp21, v14 uintptr var _ /* wc at bp+0 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, ere, err, i, len1, node, p, tmp1, tmp11, tmp2, tmp21, v, val, v14, v16 ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('['): @@ -130116,7 +130116,7 @@ _2: return err } /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */ - s++ + s = s + 1 v14 = s switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v14))) { case 0: @@ -130130,12 +130130,12 @@ _2: case int32('>'): node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOW), -int32(1)) case int32('x'): - s++ + s = s + 1 v = 0 len1 = int32(2) if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('{') { len1 = int32(8) - s++ + s = s + 1 } i = 0 for { @@ -130150,20 +130150,20 @@ _2: goto _15 _15: ; - i++ + i = i + 1 } - s += uintptr(i) + s = s + uintptr(i) if len1 == int32(8) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != int32('}') { return int32(REG_EBRACE) } - s++ + s = s + 1 } - v17 = ctx + 44 - v16 = *(*int32)(unsafe.Pointer(v17)) - *(*int32)(unsafe.Pointer(v17))++ + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, v, v, v16) - s-- + s = s - 1 case int32('{'): fallthrough case int32('+'): @@ -130179,7 +130179,7 @@ _2: /* extension: treat \| as alternation in BRE */ if !(ere != 0) { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) - s-- + s = s - 1 goto end } /* fallthrough */ @@ -130188,47 +130188,47 @@ _2: if !(ere != 0) && uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('1') < uint32(9) { /* back reference */ val = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - int32('0') - v19 = ctx + 44 - v18 = *(*int32)(unsafe.Pointer(v19)) - *(*int32)(unsafe.Pointer(v19))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v18) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(4), val, v16) if val >= (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref { - v20 = val + v16 = val } else { - v20 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref + v16 = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v20 + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmax_backref = v16 } else { /* extension: accept unknown escaped char as a literal */ goto parse_literal } } - s++ + s = s + 1 goto _13 _3: ; if (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags&int32(REG_NEWLINE) != 0 { - v22 = ctx + 44 - v21 = *(*int32)(unsafe.Pointer(v22)) - *(*int32)(unsafe.Pointer(v22))++ - tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v21) - v24 = ctx + 44 - v23 = *(*int32)(unsafe.Pointer(v24)) - *(*int32)(unsafe.Pointer(v24))++ - tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v23) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp1 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, Int32FromUint8('\n')-Int32FromInt32(1), v16) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + tmp2 = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, Int32FromUint8('\n')+Int32FromInt32(1), int32(TRE_CHAR_MAX), v16) if tmp1 != 0 && tmp2 != 0 { node = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, tmp1, tmp2) } else { node = uintptr(0) } } else { - v26 = ctx + 44 - v25 = *(*int32)(unsafe.Pointer(v26)) - *(*int32)(unsafe.Pointer(v26))++ - node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v25) + v14 = ctx + 44 + v16 = *(*int32)(unsafe.Pointer(v14)) + *(*int32)(unsafe.Pointer(v14)) = *(*int32)(unsafe.Pointer(v14)) + 1 + node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, 0, int32(TRE_CHAR_MAX), v16) } - s++ + s = s + 1 goto _13 _4: ; @@ -130237,7 +130237,7 @@ _4: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_BOL), -int32(1)) - s++ + s = s + 1 goto _13 _5: ; @@ -130246,7 +130246,7 @@ _5: goto parse_literal } node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(2), int32(ASSERT_AT_EOL), -int32(1)) - s++ + s = s + 1 goto _13 _9: ; @@ -130290,8 +130290,8 @@ parse_literal: } else { node = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, *(*Twchar_t)(unsafe.Pointer(bp)), *(*Twchar_t)(unsafe.Pointer(bp)), (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition) } - (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition++ - s += uintptr(len1) + (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fposition + 1 + s = s + uintptr(len1) goto _13 _13: ; @@ -130309,12 +130309,12 @@ end: func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { bp := tls.Alloc(16) defer tls.Free(16) - var c, depth, ere, subid, v2, v7 int32 - var err, v1, v4, v5, v6 Treg_errcode_t + var c, depth, ere, subid, v2 int32 + var err, v1 Treg_errcode_t var nbranch, nunion, s, stack, v8 uintptr var _ /* max at bp+4 */ int32 var _ /* min at bp+0 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _ = c, depth, ere, err, nbranch, nunion, s, stack, subid, v1, v2, v8 nbranch = uintptr(0) nunion = uintptr(0) ere = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fcflags & int32(REG_EXTENDED) @@ -130323,7 +130323,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { depth = 0 stack = (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstack v2 = subid - subid++ + subid = subid + 1 v1 = _tre_stack_push_int(tls, stack, v2) err = v1 if v1 != REG_OK { @@ -130331,28 +130331,28 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { } for { if !(ere != 0) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('(') || ere != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('(') { - v4 = _tre_stack_push_voidptr(tls, stack, nunion) - err = v4 - if v4 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nunion) + err = v1 + if v1 != REG_OK { return err } - v5 = _tre_stack_push_voidptr(tls, stack, nbranch) - err = v5 - if v5 != REG_OK { + v1 = _tre_stack_push_voidptr(tls, stack, nbranch) + err = v1 + if v1 != REG_OK { return err } - v7 = subid - subid++ - v6 = _tre_stack_push_int(tls, stack, v7) - err = v6 - if v6 != REG_OK { + v2 = subid + subid = subid + 1 + v1 = _tre_stack_push_int(tls, stack, v2) + err = v1 + if v1 != REG_OK { return err } - s++ + s = s + 1 if !(ere != 0) { - s++ + s = s + 1 } - depth++ + depth = depth + 1 v8 = UintptrFromInt32(0) nunion = v8 nbranch = v8 @@ -130391,7 +130391,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { break } if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('\\') { - s++ + s = s + 1 } /* handle ^* at the start of a BRE. */ if !(ere != 0) && s == (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart+uintptr(1) && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + uintptr(-Int32FromInt32(1))))) == int32('^') { @@ -130415,7 +130415,7 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('?') { *(*int32)(unsafe.Pointer(bp + 4)) = int32(1) } - s++ + s = s + 1 } if *(*int32)(unsafe.Pointer(bp + 4)) == 0 { (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fn = _tre_ast_new_literal(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, -int32(1), -int32(1), -int32(1)) @@ -130436,24 +130436,24 @@ func _tre_parse(tls *TLS, ctx uintptr) (r Treg_errcode_t) { nunion = _tre_ast_new_union(tls, (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fmem, nunion, nbranch) nbranch = uintptr(0) if c == int32('\\') && Int32FromUint8(*(*uint8)(unsafe.Pointer(s + 1))) == int32('|') { - s += uintptr(2) + s = s + uintptr(2) (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('|') { - s++ + s = s + 1 (*Ttre_parse_ctx_t)(unsafe.Pointer(ctx)).Fstart = s } else { if c == int32('\\') { if !(depth != 0) { return int32(REG_EPAREN) } - s += uintptr(2) + s = s + uintptr(2) } else { if c == int32(')') { - s++ + s = s + 1 } } - depth-- + depth = depth - 1 err = _marksub(tls, ctx, nunion, _tre_stack_pop_int(tls, stack)) if err != REG_OK { return err @@ -130594,7 +130594,7 @@ func _tre_purge_regset(tls *TLS, regset uintptr, tnfa uintptr, tag int32) { goto _1 _1: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(regset)) = -int32(1) } @@ -130654,7 +130654,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _1 _1: ; - i++ + i = i + 1 } } status = _tre_stack_push_voidptr(tls, stack, node) @@ -130695,7 +130695,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _11 _11: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i1)*4)) = id*int32(2) + int32(1) *(*int32)(unsafe.Pointer(regset + uintptr(i1+int32(1))*4)) = -int32(1) @@ -130708,7 +130708,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _12 _12: ; - i1++ + i1 = i1 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i1-int32(1))*4)) = -int32(1) goto _10 @@ -130726,7 +130726,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _13 _13: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(regset + uintptr(i2)*4)) = id1 * int32(2) *(*int32)(unsafe.Pointer(regset + uintptr(i2+int32(1))*4)) = -int32(1) @@ -130739,7 +130739,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _14 _14: ; - i2++ + i2 = i2 + 1 } (*(*Ttre_submatch_data_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data + uintptr(id1)*16))).Fparents = UintptrFromInt32(0) if i2 > 0 { @@ -130758,7 +130758,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _15 _15: ; - i2++ + i2 = i2 + 1 } *(*int32)(unsafe.Pointer(p + uintptr(i2)*4)) = -int32(1) } @@ -130793,13 +130793,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _16 _16: ; - i3++ + i3 = i3 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i3+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } else { @@ -130807,8 +130807,8 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } } else { } @@ -130843,7 +130843,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u if (*Ttre_ast_node_t)(unsafe.Pointer(left)).Fnum_tags > 0 && (*Ttre_ast_node_t)(unsafe.Pointer(right)).Fnum_tags > 0 { /* Reserve the next tag to the right child. */ reserved_tag = next_tag - next_tag++ + next_tag = next_tag + 1 } status = _tre_stack_push_int(tls, stack, reserved_tag) if status != REG_OK { @@ -130913,20 +130913,20 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _17 _17: ; - i4++ + i4 = i4 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i4+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } direction = int32(_TRE_TAG_MINIMIZE) case int32(_UNION): @@ -131010,26 +131010,26 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _18 _18: ; - i5++ + i5 = i5 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i5+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } _tre_purge_regset(tls, regset, tnfa, tag) } *(*int32)(unsafe.Pointer(regset)) = -int32(1) tag = next_tag - num_tags++ - next_tag++ + num_tags = num_tags + 1 + next_tag = next_tag + 1 } if (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fnum_submatches > 0 { /* The next two tags are reserved for markers. */ - next_tag++ + next_tag = next_tag + 1 tag = next_tag - next_tag++ + next_tag = next_tag + 1 } break } @@ -131043,7 +131043,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _19 _19: ; - i6++ + i6 = i6 + 1 } *(*int32)(unsafe.Pointer(parents + uintptr(i6)*4)) = (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fsubmatch_id *(*int32)(unsafe.Pointer(parents + uintptr(i6+int32(1))*4)) = -int32(1) @@ -131137,7 +131137,7 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u } *(*Ttre_tag_direction_t)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftag_directions + uintptr(tag_right)*4)) = int32(_TRE_TAG_MAXIMIZE) } - num_tags += int32(2) + num_tags = num_tags + int32(2) } direction = int32(_TRE_TAG_MAXIMIZE) goto _10 @@ -131159,13 +131159,13 @@ func _tre_add_tags(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr, tnfa u goto _23 _23: ; - i7++ + i7 = i7 + 1 } *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7)*4)) = tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(1))*4)) = minimal_tag *(*int32)(unsafe.Pointer((*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fminimal_tags + uintptr(i7+int32(2))*4)) = -int32(1) minimal_tag = -int32(1) - num_minimals++ + num_minimals = num_minimals + 1 } (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fend_tag = num_tags (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_tags = num_tags @@ -131220,8 +131220,8 @@ func _tre_copy_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, flags i /* XXX - e.g. [ab] has only one position but two nodes, so we are creating holes in the state space here. Not fatal, just wastes memory. */ - pos += *(*int32)(unsafe.Pointer(pos_add)) - num_copied++ + pos = pos + *(*int32)(unsafe.Pointer(pos_add)) + num_copied = num_copied + 1 } else { if (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_min == int64(-int32(3)) && flags&int32(COPY_REMOVE_TAGS) != 0 { /* Change this tag to empty. */ @@ -131460,7 +131460,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit if (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmin > int32(1) || (*Ttre_iteration_t)(unsafe.Pointer(iter)).Fmax > int32(1) { *(*int32)(unsafe.Pointer(bp)) = 0 } - iter_depth++ + iter_depth = iter_depth + 1 default: break } @@ -131501,7 +131501,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _1 _1: ; - j++ + j = j + 1 } if (*Ttre_iteration_t)(unsafe.Pointer(iter1)).Fmax == -int32(1) { /* No upper limit. */ @@ -131544,7 +131544,7 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit goto _3 _3: ; - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer(bp)) = pos_add_save @@ -131561,8 +131561,8 @@ func _tre_expand_ast(tls *TLS, mem Ttre_mem_t, stack uintptr, ast uintptr, posit (*Ttre_ast_node_t)(unsafe.Pointer(node)).Fobj = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Fobj (*Ttre_ast_node_t)(unsafe.Pointer(node)).Ftype1 = (*Ttre_ast_node_t)(unsafe.Pointer(seq1)).Ftype1 } - iter_depth-- - pos_add_total += *(*int32)(unsafe.Pointer(bp)) - pos_add_last + iter_depth = iter_depth - 1 + pos_add_total = pos_add_total + (*(*int32)(unsafe.Pointer(bp)) - pos_add_last) if iter_depth == 0 { *(*int32)(unsafe.Pointer(bp)) = pos_add_total } @@ -131625,7 +131625,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _1 _1: ; - num_tags++ + num_tags = num_tags + 1 } s1 = 0 for { @@ -131635,7 +131635,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _2 _2: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131645,7 +131645,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _3 _3: ; - s2++ + s2 = s2 + 1 } new_set = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), int32(1), uint64(56)*Uint64FromInt32(s1+s2+Int32FromInt32(1))) if !(new_set != 0) { @@ -131674,7 +131674,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _5 _5: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, Uint64FromInt64(4)*Uint64FromInt32(i+num_tags+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131689,7 +131689,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _6 _6: ; - j++ + j = j + 1 } i = 0 for { @@ -131700,7 +131700,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _7 _7: ; - i++ + i = i + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j+i)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1)*56))).Ftags = new_tags @@ -131708,7 +131708,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _4 _4: ; - s1++ + s1 = s1 + 1 } s2 = 0 for { @@ -131734,7 +131734,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _9 _9: ; - i++ + i = i + 1 } new_tags = X__tre_mem_alloc_impl(tls, mem, 0, UintptrFromInt32(0), 0, uint64(4)*Uint64FromInt32(i+Int32FromInt32(1))) if new_tags == UintptrFromInt32(0) { @@ -131749,7 +131749,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _10 _10: ; - j++ + j = j + 1 } *(*int32)(unsafe.Pointer(new_tags + uintptr(j)*4)) = -int32(1) (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Ftags = new_tags @@ -131757,7 +131757,7 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u goto _8 _8: ; - s2++ + s2 = s2 + 1 } (*(*Ttre_pos_and_tags_t)(unsafe.Pointer(new_set + uintptr(s1+s2)*56))).Fposition = -int32(1) return new_set @@ -131771,9 +131771,9 @@ func _tre_set_union(tls *TLS, mem Ttre_mem_t, set1 uintptr, set2 uintptr, tags u // set to the number of tags seen on the path. */ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, assertions uintptr, num_tags_seen uintptr) (r Treg_errcode_t) { var bottom, i int32 - var cat, iter, lit, uni, p2 uintptr + var cat, iter, lit, uni, v2 uintptr var status Treg_errcode_t - _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, p2 + _, _, _, _, _, _, _, _ = bottom, cat, i, iter, lit, status, uni, v2 bottom = _tre_stack_num_objects(tls, stack) status = REG_OK if num_tags_seen != 0 { @@ -131802,7 +131802,7 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser goto _1 _1: ; - i++ + i = i + 1 } if *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) < 0 { *(*int32)(unsafe.Pointer(tags + uintptr(i)*4)) = int32((*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) @@ -131810,13 +131810,13 @@ func _tre_match_empty(tls *TLS, stack uintptr, node uintptr, tags uintptr, asser } } if num_tags_seen != 0 { - *(*int32)(unsafe.Pointer(num_tags_seen))++ + *(*int32)(unsafe.Pointer(num_tags_seen)) = *(*int32)(unsafe.Pointer(num_tags_seen)) + 1 } } case int64(-int32(2)): if assertions != UintptrFromInt32(0) { - p2 = assertions - *(*int32)(unsafe.Pointer(p2)) = int32(int64(*(*int32)(unsafe.Pointer(p2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) + v2 = assertions + *(*int32)(unsafe.Pointer(v2)) = int32(int64(*(*int32)(unsafe.Pointer(v2))) | (*Ttre_literal_t)(unsafe.Pointer(lit)).Fcode_max) } case int64(-int32(1)): default: @@ -132117,9 +132117,9 @@ func _tre_compute_nfl(tls *TLS, mem Ttre_mem_t, stack uintptr, tree uintptr) (r // // /* Adds a transition from each position in `p1' to each position in `p2'. */ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, counts uintptr, offs uintptr) (r Treg_errcode_t) { - var dup, i, j, k, l, prev_p2_pos, v1, v2, v6 int32 + var dup, i, j, k, l, prev_p2_pos, v1, v2 int32 var orig_p2, trans uintptr - _, _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2, v6 + _, _, _, _, _, _, _, _, _, _ = dup, i, j, k, l, orig_p2, prev_p2_pos, trans, v1, v2 orig_p2 = p2 if transitions != UintptrFromInt32(0) { for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { @@ -132173,7 +132173,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _3 _3: ; - i++ + i = i + 1 } (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes = Xmalloc(tls, uint64(8)*Uint64FromInt32(i+Int32FromInt32(1))) if (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes == UintptrFromInt32(0) { @@ -132188,7 +132188,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _4 _4: ; - i++ + i = i + 1 } *(*Ttre_ctype_t)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Fneg_classes + uintptr(i)*8)) = Uint64FromInt32(0) } else { @@ -132198,13 +132198,13 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun i = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { - i++ + i = i + 1 } } j = 0 if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) >= 0 { - j++ + j = j + 1 } } /* If we are overwriting a transition, free the old tag array. */ @@ -132222,7 +132222,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun if (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags != UintptrFromInt32(0) { for *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) >= 0 { *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(i)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Ftags + uintptr(i)*4)) - i++ + i = i + 1 } } l = i @@ -132243,14 +132243,14 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun goto _5 _5: ; - k++ + k = k + 1 } if !(dup != 0) { - v6 = l - l++ - *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v6)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) + v1 = l + l = l + 1 + *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(v1)*4)) = *(*int32)(unsafe.Pointer((*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Ftags + uintptr(j)*4)) } - j++ + j = j + 1 } } *(*int32)(unsafe.Pointer((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans)).Ftags + uintptr(l)*4)) = -int32(1) @@ -132265,7 +132265,7 @@ func _tre_make_trans(tls *TLS, p1 uintptr, p2 uintptr, transitions uintptr, coun for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition >= 0 { p2 = orig_p2 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p2)).Fposition >= 0 { - *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4))++ + *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) = *(*int32)(unsafe.Pointer(counts + uintptr((*Ttre_pos_and_tags_t)(unsafe.Pointer(p1)).Fposition)*4)) + 1 p2 += 56 } p1 += 56 @@ -132448,7 +132448,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { tmp_ast_l = tree v2 = bp + 44 v1 = *(*int32)(unsafe.Pointer(v2)) - *(*int32)(unsafe.Pointer(v2))++ + *(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1 tmp_ast_r = _tre_ast_new_literal(tls, mem, 0, 0, v1) if tmp_ast_r == UintptrFromInt32(0) { errcode = int32(REG_ESPACE) @@ -132493,7 +132493,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _3 _3: ; - i++ + i = i + 1 } _tre_ast_to_tnfa(tls, tree, UintptrFromInt32(0), counts, UintptrFromInt32(0)) add = 0 @@ -132503,12 +132503,12 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { break } *(*int32)(unsafe.Pointer(offs + uintptr(i)*4)) = add - add += *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1) + add = add + (*(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) + int32(1)) *(*int32)(unsafe.Pointer(counts + uintptr(i)*4)) = 0 goto _4 _4: ; - i++ + i = i + 1 } transitions = Xcalloc(tls, uint64(Uint32FromInt32(add)+uint32(1)), uint64(56)) if transitions == UintptrFromInt32(0) { @@ -132530,7 +132530,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { p = (*Ttre_ast_node_t)(unsafe.Pointer(tree)).Ffirstpos i = 0 for (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fposition >= 0 { - i++ + i = i + 1 p += 56 } initial = Xcalloc(tls, uint64(Uint32FromInt32(i)+uint32(1)), uint64(56)) @@ -132561,7 +132561,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { goto _6 _6: ; - j++ + j = j + 1 } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags = Xmalloc(tls, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) if !((*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags != 0) { @@ -132573,7 +132573,7 @@ func Xregcomp(tls *TLS, preg uintptr, regex uintptr, cflags int32) (r int32) { Xmemcpy(tls, (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Ftags, (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Ftags, uint64(4)*Uint64FromInt32(j+Int32FromInt32(1))) } (*(*Ttre_tnfa_transition_t)(unsafe.Pointer(initial + uintptr(i)*56))).Fassertions = (*Ttre_pos_and_tags_t)(unsafe.Pointer(p)).Fassertions - i++ + i = i + 1 goto _5 _5: ; @@ -132636,7 +132636,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions != 0 { Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Ftransitions) @@ -132669,7 +132669,7 @@ func Xregfree(tls *TLS, preg uintptr) { goto _3 _3: ; - i++ + i = i + 1 } Xfree(tls, (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fsubmatch_data) } @@ -132710,11 +132710,11 @@ func Xregerror(tls *TLS, e int32, preg uintptr, buf uintptr, size Tsize_t) (r Ts goto _1 _1: ; - e-- - s += uintptr(Xstrlen(tls, s) + uint64(1)) + e = e - 1 + s = s + uintptr(Xstrlen(tls, s)+uint64(1)) } if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - s++ + s = s + 1 } s = X__lctrans_cur(tls, s) return Uint64FromInt32(int32(1) + Xsnprintf(tls, buf, size, __ccgo_ts+15, VaList(bp+8, s))) @@ -132757,7 +132757,7 @@ func _tre_tag_order(tls *TLS, num_tags int32, tag_directions uintptr, t1 uintptr goto _1 _1: ; - i++ + i = i + 1 } /* assert(0);*/ return 0 @@ -132809,13 +132809,13 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags defer tls.Free(16) var buf, reach, reach_i, reach_next, reach_next_i, reach_pos, str_byte, tag_i, tmp_buf, tmp_iptr, tmp_tags, trans_i uintptr var end, i, new_match, num_tags, reg_newline, reg_notbol, reg_noteol, skip, start, v18 int32 - var match_eo, pos, pos_add_next, v10, v7 Tregoff_t + var match_eo, pos, pos_add_next, v7 Tregoff_t var pbytes, rbytes, tbytes, total_bytes, xbytes Tsize_t var prev_c Ttre_char_t var ret Treg_errcode_t - var v1, v2, v3, v4 uint64 + var v1 uint64 var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v10, v18, v2, v3, v4, v7 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, end, i, match_eo, new_match, num_tags, pbytes, pos, pos_add_next, prev_c, rbytes, reach, reach_i, reach_next, reach_next_i, reach_pos, reg_newline, reg_notbol, reg_noteol, ret, skip, start, str_byte, tag_i, tbytes, tmp_buf, tmp_iptr, tmp_tags, total_bytes, trans_i, xbytes, v1, v18, v7 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -132868,44 +132868,44 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags } else { v1 = uint64(0) } - tmp_buf += uintptr(v1) + tmp_buf = tmp_buf + uintptr(v1) reach_next = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v2 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v2 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v2) + tmp_buf = tmp_buf + uintptr(v1) reach = tmp_buf - tmp_buf += uintptr(rbytes) + tmp_buf = tmp_buf + uintptr(rbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v3 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v3 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v3) + tmp_buf = tmp_buf + uintptr(v1) reach_pos = tmp_buf - tmp_buf += uintptr(pbytes) + tmp_buf = tmp_buf + uintptr(pbytes) if Uint64FromInt64(int64(tmp_buf))%uint64(8) != 0 { - v4 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) + v1 = uint64(8) - Uint64FromInt64(int64(tmp_buf))%uint64(8) } else { - v4 = uint64(0) + v1 = uint64(0) } - tmp_buf += uintptr(v4) + tmp_buf = tmp_buf + uintptr(v1) i = 0 for { if !(i < (*Ttre_tnfa_t)(unsafe.Pointer(tnfa)).Fnum_states) { break } (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) (*(*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next + uintptr(i)*16))).Ftags = tmp_buf - tmp_buf += uintptr(xbytes) + tmp_buf = tmp_buf + uintptr(xbytes) goto _5 _5: ; - i++ + i = i + 1 } i = 0 for { @@ -132916,10 +132916,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _6 _6: ; - i++ + i = i + 1 } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v7 if v7 <= 0 { @@ -132927,10 +132927,10 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos = 0 reach_next_i = reach_next for int32(1) != 0 { @@ -132953,7 +132953,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _8 _8: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != 0 { @@ -132976,7 +132976,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _9 _9: ; - i++ + i = i + 1 } } (*(*Ttre_reach_pos_t)(unsafe.Pointer(reach_pos + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*16))).Fpos = pos @@ -132997,18 +132997,18 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags break } prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v10 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v10 - if v10 <= 0 { + pos = pos + pos_add_next + v7 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v7 + if v7 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) /* Swap `reach' and `reach_next'. */ reach_i = reach reach = reach_next @@ -133043,7 +133043,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _12 _12: ; - i += int32(2) + i = i + int32(2) } if !(skip != 0) { (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_next_i)).Fstate = (*Ttre_tnfa_reach_t)(unsafe.Pointer(reach_i)).Fstate @@ -133092,7 +133092,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _15 _15: ; - i++ + i = i + 1 } tag_i = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tag_i != UintptrFromInt32(0) { @@ -133123,7 +133123,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _16 _16: ; - i++ + i = i + 1 } } reach_next_i += 16 @@ -133147,7 +133147,7 @@ func _tre_tnfa_run_parallel(tls *TLS, tnfa uintptr, string1 uintptr, match_tags goto _17 _17: ; - i++ + i = i + 1 } } tmp_tags = tmp_iptr @@ -133228,13 +133228,13 @@ func _tre_tnfa_run_backtrack(tls *TLS, tnfa uintptr, string1 uintptr, match_tags bp := tls.Alloc(16) defer tls.Free(16) var bt, empty_br_match, i, i1, i2, i3, i4, next_c_start, reg_newline, reg_notbol, reg_noteol, result, ret, v20 int32 - var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v11, v12, v3 Tregoff_t + var bt_len, eo, match_eo, pos, pos_add_next, pos_start, so, v3 Tregoff_t var mem Ttre_mem_t - var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v18, v6 uintptr + var next_state, next_tags, pmatch, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v6 uintptr var prev_c Ttre_char_t var s, s1, stack Ttre_backtrack_t var _ /* next_c at bp+0 */ Ttre_char_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v11, v12, v18, v20, v3, v6 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bt, bt_len, empty_br_match, eo, i, i1, i2, i3, i4, match_eo, mem, next_c_start, next_state, next_tags, pmatch, pos, pos_add_next, pos_start, prev_c, reg_newline, reg_notbol, reg_noteol, result, ret, s, s1, so, stack, state, states_seen, str_byte, str_byte_start, tags, tmp, tmp1, trans_i, v20, v3, v6 /* State variables required by GET_NEXT_WCHAR. */ prev_c = 0 *(*Ttre_char_t)(unsafe.Pointer(bp)) = 0 @@ -133298,7 +133298,7 @@ retry: goto _1 _1: ; - i++ + i = i + 1 } i = 0 for { @@ -133309,12 +133309,12 @@ retry: goto _2 _2: ; - i++ + i = i + 1 } state = UintptrFromInt32(0) pos = pos_start prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next + pos = pos + pos_add_next v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) pos_add_next = v3 if v3 <= 0 { @@ -133322,10 +133322,10 @@ retry: ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) pos_start = pos next_c_start = *(*Ttre_char_t)(unsafe.Pointer(bp)) str_byte_start = str_byte @@ -133395,7 +133395,7 @@ retry: goto _5 _5: ; - i1++ + i1 = i1 + 1 } tmp = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags if tmp != 0 { @@ -133445,7 +133445,7 @@ _9: goto _10 _10: ; - i2++ + i2 = i2 + 1 } } } @@ -133476,21 +133476,21 @@ _9: *(*int32)(unsafe.Pointer(states_seen + uintptr((*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Fstate_id)*4)) = empty_br_match /* Advance in input string and resync `prev_c', `next_c' and pos. */ - str_byte += uintptr(bt_len - int64(1)) - pos += bt_len - int64(1) + str_byte = str_byte + uintptr(bt_len-int64(1)) + pos = pos + (bt_len - int64(1)) prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v11 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v11 - if v11 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } else { goto backtrack } @@ -133501,18 +133501,18 @@ _9: } /* Read the next character. */ prev_c = *(*Ttre_char_t)(unsafe.Pointer(bp)) - pos += pos_add_next - v12 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) - pos_add_next = v12 - if v12 <= 0 { + pos = pos + pos_add_next + v3 = int64(Xmbtowc(tls, bp, str_byte, uint64(MB_LEN_MAX))) + pos_add_next = v3 + if v3 <= 0 { if pos_add_next < 0 { ret = int32(REG_NOMATCH) goto error_exit } else { - pos_add_next++ + pos_add_next = pos_add_next + 1 } } - str_byte += uintptr(pos_add_next) + str_byte = str_byte + uintptr(pos_add_next) } next_state = UintptrFromInt32(0) trans_i = state @@ -133583,7 +133583,7 @@ _9: goto _14 _14: ; - i3++ + i3 = i3 + 1 } tmp1 = (*Ttre_tnfa_transition_t)(unsafe.Pointer(trans_i)).Ftags for { @@ -133611,9 +133611,9 @@ _9: /* Update the tag values. */ if next_tags != 0 { for *(*int32)(unsafe.Pointer(next_tags)) >= 0 { - v18 = next_tags + v6 = next_tags next_tags += 4 - *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v18)))*8)) = pos + *(*Tregoff_t)(unsafe.Pointer(tags + uintptr(*(*int32)(unsafe.Pointer(v6)))*8)) = pos } } goto _17 @@ -133640,7 +133640,7 @@ backtrack: goto _19 _19: ; - i4++ + i4 = i4 + 1 } stack = (*Ttre_backtrack_struct)(unsafe.Pointer(stack)).Fprev } else { @@ -133696,8 +133696,8 @@ error_exit: func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tnfa uintptr, tags uintptr, match_eo Tregoff_t) { var i, j uint32 var parents, submatch_data uintptr - var v1, v3 Tregoff_t - _, _, _, _, _, _ = i, j, parents, submatch_data, v1, v3 + var v1 Tregoff_t + _, _, _, _, _ = i, j, parents, submatch_data, v1 i = uint32(0) if match_eo >= 0 && !(cflags&Int32FromInt32(REG_NOSUB) != 0) { /* Construct submatch offsets from the tags. */ @@ -133720,7 +133720,7 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } - i++ + i = i + 1 } /* Reset all submatches that are not within all of their parent submatches. */ @@ -133736,23 +133736,23 @@ func _tre_fill_pmatch(tls *TLS, nmatch Tsize_t, pmatch uintptr, cflags int32, tn break } if (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so < (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_so || (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo > (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(*(*int32)(unsafe.Pointer(parents + uintptr(j)*4)))*16))).Frm_eo { - v3 = int64(-Int32FromInt32(1)) - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v3 - (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v3 + v1 = int64(-Int32FromInt32(1)) + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = v1 + (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = v1 } goto _2 _2: ; - j++ + j = j + 1 } } - i++ + i = i + 1 } } for uint64(i) < nmatch { (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_so = int64(-int32(1)) (*(*Tregmatch_t)(unsafe.Pointer(pmatch + uintptr(i)*16))).Frm_eo = int64(-int32(1)) - i++ + i = i + 1 } } @@ -133907,7 +133907,7 @@ func X__tre_mem_alloc_impl(tls *TLS, mem Ttre_mem_t, provided int32, provided_bl } else { v1 = uint64(0) } - size += v1 + size = size + v1 /* Allocate from current block. */ ptr = (*Ttre_mem_struct)(unsafe.Pointer(mem)).Fptr *(*uintptr)(unsafe.Pointer(mem + 16)) += uintptr(size) @@ -133978,7 +133978,7 @@ func _keyhash(tls *TLS, k uintptr) (r Tsize_t) { h = uint64(0) for *(*uint8)(unsafe.Pointer(p)) != 0 { v1 = p - p++ + p = p + 1 h = uint64(31)*h + uint64(*(*uint8)(unsafe.Pointer(v1))) } return h @@ -134001,7 +134001,7 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { goto _1 _1: ; - newsize *= uint64(2) + newsize = newsize * uint64(2) } (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries = Xcalloc(tls, newsize, uint64(16)) if !((*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fentries != 0) { @@ -134029,8 +134029,8 @@ func _resize(tls *TLS, nel Tsize_t, htab uintptr) (r int32) { _3: ; v4 = j - j++ - i += v4 + j = j + 1 + i = i + v4 } *(*TENTRY)(unsafe.Pointer(newe)) = *(*TENTRY)(unsafe.Pointer(e)) } @@ -134073,8 +134073,8 @@ func _lookup(tls *TLS, key uintptr, hash Tsize_t, htab uintptr) (r uintptr) { _1: ; v2 = j - j++ - i += v2 + j = j + 1 + i = i + v2 } return e } @@ -134130,11 +134130,11 @@ func ___hsearch_r(tls *TLS, item TENTRY, action TACTION, retval uintptr, htab ui } *(*TENTRY)(unsafe.Pointer(e)) = item v2 = (*Thsearch_data)(unsafe.Pointer(htab)).F__tab + 16 - *(*Tsize_t)(unsafe.Pointer(v2))++ + *(*Tsize_t)(unsafe.Pointer(v2)) = *(*Tsize_t)(unsafe.Pointer(v2)) + 1 v1 = *(*Tsize_t)(unsafe.Pointer(v2)) if v1 > (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask-(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fmask/uint64(4) { if !(_resize(tls, uint64(2)*(*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused, htab) != 0) { - (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused-- + (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused = (*t__tab)(unsafe.Pointer((*Thsearch_data)(unsafe.Pointer(htab)).F__tab)).Fused - 1 (*TENTRY)(unsafe.Pointer(e)).Fkey = uintptr(0) *(*uintptr)(unsafe.Pointer(retval)) = uintptr(0) return 0 @@ -134213,7 +134213,7 @@ func Xlsearch(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, goto _2 _2: ; - i++ + i = i + 1 } *(*Tsize_t)(unsafe.Pointer(nelp)) = n + uint64(1) return Xmemcpy(tls, p+uintptr(n)*uintptr(v1), key, width) @@ -134245,7 +134245,7 @@ func Xlfind(tls *TLS, key uintptr, base uintptr, nelp uintptr, width Tsize_t, __ goto _2 _2: ; - i++ + i = i + 1 } return uintptr(0) } @@ -134266,9 +134266,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui defer func() { trc("-> %v", r) }() } var a [97]uintptr - var c, i, v1, v2, v4, v5, v6, v7, v8 int32 + var c, i, v1 int32 var child, deleted, n, parent uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1, v2, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _ = a, c, child, deleted, i, n, parent, v1 if !(rootp != 0) { return uintptr(0) } @@ -134277,11 +134277,11 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui /* *a[0] is an arbitrary non-null pointer that is returned when the root node is deleted. */ v1 = i - i++ + i = i + 1 + a[v1] = rootp + v1 = i + i = i + 1 a[v1] = rootp - v2 = i - i++ - a[v2] = rootp for { if !(n != 0) { return uintptr(0) @@ -134290,9 +134290,9 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if !(c != 0) { break } - v4 = i - i++ - a[v4] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _3 _3: @@ -134301,14 +134301,14 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui if *(*uintptr)(unsafe.Pointer(n + 8)) != 0 { /* free the preceding node instead of the deleted one. */ deleted = n - v5 = i - i++ - a[v5] = n + 8 + v1 = i + i = i + 1 + a[v1] = n + 8 n = *(*uintptr)(unsafe.Pointer(n + 8)) for *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) != 0 { - v6 = i - i++ - a[v6] = n + 8 + 1*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + 1*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + 1*8)) } (*Tnode1)(unsafe.Pointer(deleted)).Fkey = (*Tnode1)(unsafe.Pointer(n)).Fkey @@ -134318,13 +134318,13 @@ func Xtdelete(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r ui } /* freed node has at most one child, move it up and rebalance. */ Xfree(tls, n) - i-- - v7 = i - *(*uintptr)(unsafe.Pointer(a[v7])) = child + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = child for { - i-- - v8 = i - if !(v8 != 0 && X__tsearch_balance(tls, a[i]) != 0) { + i = i - 1 + v1 = i + if !(v1 != 0 && X__tsearch_balance(tls, a[i]) != 0) { break } } @@ -134465,17 +134465,17 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u defer func() { trc("-> %v", r1) }() } var a [96]uintptr - var c, i, v1, v3, v5, v6 int32 + var c, i, v1 int32 var n, r, v4 uintptr var v7 bool - _, _, _, _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v3, v4, v5, v6, v7 + _, _, _, _, _, _, _, _ = a, c, i, n, r, v1, v4, v7 if !(rootp != 0) { return uintptr(0) } n = *(*uintptr)(unsafe.Pointer(rootp)) i = 0 v1 = i - i++ + i = i + 1 a[v1] = rootp for { if !(n != 0) { @@ -134485,9 +134485,9 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u if !(c != 0) { return n } - v3 = i - i++ - a[v3] = n + 8 + BoolUintptr(c > 0)*8 + v1 = i + i = i + 1 + a[v1] = n + 8 + BoolUintptr(c > 0)*8 n = *(*uintptr)(unsafe.Pointer(n + 8 + BoolUintptr(c > 0)*8)) goto _2 _2: @@ -134502,15 +134502,15 @@ func Xtsearch(tls *TLS, key uintptr, rootp uintptr, __ccgo_fp_cmp uintptr) (r1 u *(*uintptr)(unsafe.Pointer(r + 8)) = v4 (*Tnode1)(unsafe.Pointer(r)).Fh = int32(1) /* insert new node, rebalance ancestors. */ - i-- - v5 = i - *(*uintptr)(unsafe.Pointer(a[v5])) = r + i = i - 1 + v1 = i + *(*uintptr)(unsafe.Pointer(a[v1])) = r for { if v7 = i != 0; v7 { - i-- - v6 = i + i = i - 1 + v1 = i } - if !(v7 && X__tsearch_balance(tls, a[v6]) != 0) { + if !(v7 && X__tsearch_balance(tls, a[v1]) != 0) { break } } @@ -134657,8 +134657,8 @@ func Xselect(tls *TLS, n int32, rfds uintptr, wfds uintptr, efds uintptr, tv uin us = int64(999999) ns = int64(999999999) } else { - s += us / int64(1000000) - us %= int64(1000000) + s = s + us/int64(1000000) + us = us % int64(1000000) ns = us * int64(1000) } if tv != 0 { @@ -134889,7 +134889,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) bp := tls.Alloc(80) defer tls.Free(80) var old, r, v11, v12, v17, v18, v4, v5 int32 - var v1, v10, v16, v22, v23, v24, v3, v9 uintptr + var v1, v10, v16, v3, v9 uintptr var v2 int64 var _ /* ksa at bp+16 */ Tk_sigaction var _ /* ksa_old at bp+48 */ Tk_sigaction @@ -134897,7 +134897,7 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) Fr [0][2]Tuint32_t Fv Tuint64_t } - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, v1, v10, v11, v12, v16, v17, v18, v2, v22, v23, v24, v3, v4, v5, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, r, v1, v10, v11, v12, v16, v17, v18, v2, v3, v4, v5, v9 if sa != 0 { if uint64(*(*uintptr)(unsafe.Pointer(sa))) > uint64(1) { v1 = uintptr(unsafe.Pointer(&_handler_set)) + uintptr(Uint64FromInt32(sig-Int32FromInt32(1))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 @@ -135014,24 +135014,24 @@ func X__libc_sigaction(tls *TLS, sig int32, sa uintptr, old1 uintptr) (r1 int32) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags = Uint64FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags) (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Fflags |= uint64(0x04000000) if Uint32FromInt32((*Tsigaction)(unsafe.Pointer(sa)).Fsa_flags)&uint32(4) != 0 { - v22 = __ccgo_fp(X__restore_rt) + v1 = __ccgo_fp(X__restore_rt) } else { - v22 = __ccgo_fp(X__restore) + v1 = __ccgo_fp(X__restore) } - (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v22 + (*(*Tk_sigaction)(unsafe.Pointer(bp + 16))).Frestorer = v1 Xmemcpy(tls, bp+16+24, sa+8, Uint64FromInt32(Int32FromInt32(_NSIG)/Int32FromInt32(8))) } if sa != 0 { - v23 = bp + 16 + v1 = bp + 16 } else { - v23 = uintptr(0) + v1 = uintptr(0) } if old1 != 0 { - v24 = bp + 48 + v3 = bp + 48 } else { - v24 = uintptr(0) + v3 = uintptr(0) } - r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v23), int64(v24), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) + r = int32(X__syscall4(tls, int64(SYS_rt_sigaction), int64(sig), int64(v1), int64(v3), int64(Int32FromInt32(_NSIG)/Int32FromInt32(8)))) if old1 != 0 && !(r != 0) { *(*uintptr)(unsafe.Pointer(old1)) = (*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fhandler (*Tsigaction)(unsafe.Pointer(old1)).Fsa_flags = Int32FromUint64((*(*Tk_sigaction)(unsafe.Pointer(bp + 48))).Fflags) @@ -135133,7 +135133,7 @@ func Xsigandset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135209,7 +135209,7 @@ func Xsigisemptyset(tls *TLS, set uintptr) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } return int32(1) } @@ -135248,7 +135248,7 @@ func Xsigorset(tls *TLS, dest uintptr, left uintptr, right uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } return 0 } @@ -135584,7 +135584,7 @@ func _fstatat_statx(tls *TLS, fd int32, path uintptr, st uintptr, flag int32) (r var ret int32 var _ /* stx at bp+0 */ Tstatx1 _ = ret - flag |= int32(AT_NO_AUTOMOUNT) + flag = flag | int32(AT_NO_AUTOMOUNT) ret = int32(X__syscall5(tls, int64(SYS_statx), int64(fd), int64(path), int64(flag), int64(Int32FromInt32(0x7ff)), int64(bp))) if ret != 0 { return ret @@ -135751,7 +135751,7 @@ func X__futimesat(tls *TLS, dirfd int32, pathname uintptr, times uintptr) (r int goto _1 _1: ; - i++ + i = i + 1 } } if times != 0 { @@ -135954,7 +135954,7 @@ func Xutimensat(tls *TLS, fd int32, path uintptr, times uintptr, flags int32) (r goto _1 _1: ; - i++ + i = i + 1 } } r = int32(X__syscall3(tls, int64(SYS_futimesat), int64(fd), int64(path), int64(tv))) @@ -136063,19 +136063,19 @@ func X__fmodeflags(tls *TLS, mode uintptr) (r int32) { } } if Xstrchr(tls, mode, int32('x')) != 0 { - flags |= int32(O_EXCL) + flags = flags | int32(O_EXCL) } if Xstrchr(tls, mode, int32('e')) != 0 { - flags |= int32(O_CLOEXEC) + flags = flags | int32(O_CLOEXEC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) != int32('r') { - flags |= int32(O_CREAT) + flags = flags | int32(O_CREAT) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('w') { - flags |= int32(O_TRUNC) + flags = flags | int32(O_TRUNC) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(mode))) == int32('a') { - flags |= int32(O_APPEND) + flags = flags | int32(O_APPEND) } return flags } @@ -136120,7 +136120,7 @@ func X__overflow(tls *TLS, f uintptr, _c int32) (r int32) { v1 = *(*uint8)(unsafe.Pointer(bp)) v3 = f + 40 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(v2)) = v1 return Int32FromUint8(v1) } @@ -136229,13 +136229,13 @@ func X__stdio_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if Uint64FromInt64(cnt) <= (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len { return Uint64FromInt64(cnt) } - cnt = Tssize_t(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*[2]Tiovec)(unsafe.Pointer(bp)))[0].Fiov_len) (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(cnt) if (*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(len1-uint64(1)))) = *(*uint8)(unsafe.Pointer(v3)) } return len1 @@ -136257,12 +136257,12 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) bp := tls.Alloc(32) defer tls.Free(32) var cnt Tssize_t - var iov, v2, v3, v4 uintptr + var iov, v2, v3 uintptr var iovcnt int32 var rem Tsize_t var v5 uint64 var _ /* iovs at bp+0 */ [2]Tiovec - _, _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v4, v5 + _, _, _, _, _, _, _ = cnt, iov, iovcnt, rem, v2, v3, v5 *(*[2]Tiovec)(unsafe.Pointer(bp)) = [2]Tiovec{ 0: { Fiov_base: (*TFILE)(unsafe.Pointer(f)).Fwbase, @@ -136286,11 +136286,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) return len1 } if cnt < 0 { - v4 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v4 - v3 = v4 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) if iovcnt == int32(2) { v5 = uint64(0) @@ -136299,11 +136299,11 @@ func X__stdio_write(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) } return v5 } - rem -= Uint64FromInt64(cnt) + rem = rem - Uint64FromInt64(cnt) if Uint64FromInt64(cnt) > (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len { - cnt = Tssize_t(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) + cnt = Int64FromUint64(uint64(cnt) - (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len) iov += 16 - iovcnt-- + iovcnt = iovcnt - 1 } (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base = (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_base + uintptr(cnt) (*(*Tiovec)(unsafe.Pointer(iov))).Fiov_len -= Uint64FromInt64(cnt) @@ -136333,9 +136333,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr + var v1, v2 uintptr var v4 int32 - _, _, _, _ = v1, v2, v3, v4 + _, _, _ = v1, v2, v4 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136349,9 +136349,9 @@ func X__toread(tls *TLS, f uintptr) (r int32) { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) return -int32(1) } - v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_EOF) != 0 { v4 = -int32(1) } else { @@ -136372,8 +136372,8 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2 uintptr - _, _ = v1, v2 + var v1 uintptr + _ = v1 *(*int32)(unsafe.Pointer(f + 136)) |= (*TFILE)(unsafe.Pointer(f)).Fmode - int32(1) if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_NOWR) != 0 { *(*uint32)(unsafe.Pointer(f)) |= uint32(F_ERR) @@ -136384,9 +136384,9 @@ func X__towrite(tls *TLS, f uintptr) (r int32) { (*TFILE)(unsafe.Pointer(f)).Frend = v1 (*TFILE)(unsafe.Pointer(f)).Frpos = v1 /* Activate write through the buffer. */ - v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 + v1 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) return 0 } @@ -136555,8 +136555,8 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 if !(f != 0) { // libbsd fpurge test fails w/o this. return int32(1) } @@ -136565,9 +136565,9 @@ func X__fpurge(tls *TLS, f uintptr) (r int32) { v1 = v2 (*TFILE)(unsafe.Pointer(f)).Fwbase = v1 (*TFILE)(unsafe.Pointer(f)).Fwpos = v1 - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 return 0 } @@ -136638,7 +136638,7 @@ func Xfclose(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v1 r = Xfflush(tls, f) - r |= (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) + r = r | (*(*func(*TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fclose1})))(tls, f) if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -136751,16 +136751,16 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r1) }() } - var __need_unlock, __need_unlock1, r, v2, v3 int32 - var v4, v5, v6 uintptr - _, _, _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v3, v4, v5, v6 + var __need_unlock, __need_unlock1, r, v2 int32 + var v4, v5 uintptr + _, _, _, _, _, _ = __need_unlock, __need_unlock1, r, v2, v4, v5 if !(f != 0) { r = 0 if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stdout_used)))) } if AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used))) != 0 { - r |= Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) + r = r | Xfflush(tls, AtomicLoadPUintptr(uintptr(unsafe.Pointer(&X__stderr_used)))) } f = *(*uintptr)(unsafe.Pointer(X__ofl_lock(tls))) for { @@ -136774,7 +136774,7 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { } __need_unlock = v2 if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { - r |= Xfflush(tls, f) + r = r | Xfflush(tls, f) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -136788,11 +136788,11 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { return r } if AtomicLoadPInt32(f+140) >= 0 { - v3 = ___lockfile(tls, f) + v2 = ___lockfile(tls, f) } else { - v3 = 0 + v2 = 0 } - __need_unlock1 = v3 + __need_unlock1 = v2 /* If writing, flush output */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, uintptr(0), uint64(0)) @@ -136813,9 +136813,9 @@ func Xfflush(tls *TLS, f uintptr) (r1 int32) { v4 = v5 (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 - v6 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v6 - (*TFILE)(unsafe.Pointer(f)).Frpos = v6 + v4 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v4 + (*TFILE)(unsafe.Pointer(f)).Frpos = v4 if __need_unlock1 != 0 { ___unlockfile(tls, f) } @@ -136831,9 +136831,9 @@ func Xfflush_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc(tls *TLS, f uintptr) (r int32) { - var c, old, v1, v12, v15, v16, v2, v4, v8, v9 int32 + var c, old, v1, v12, v2, v4, v8, v9 int32 var v14, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v15, v16, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v2, v4, v5, v6, v7, v8, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -136849,46 +136849,46 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 + c = v1 v7 = f + 140 for { old = AtomicLoadPInt32(v7) goto _11 _11: ; - v8 = old + v2 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1538) - v9 = v8 + v4 = v2 goto _10 _10: ; - if !(v9 != old) { + if !(v4 != old) { break } } - v12 = old + v8 = old goto _13 _13: - if v12&int32(MAYBE_WAITERS) != 0 { + if v8&int32(MAYBE_WAITERS) != 0 { v14 = f + 140 - v15 = int32(1) - v16 = int32(1) - if v16 != 0 { - v16 = int32(FUTEX_PRIVATE) + v9 = int32(1) + v12 = int32(1) + if v12 != 0 { + v12 = int32(FUTEX_PRIVATE) } - if v15 < Int32FromInt32(0) { - v15 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v15)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v15)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -136907,7 +136907,7 @@ func Xfgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -136930,9 +136930,9 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { defer tls.Free(16) var __need_unlock, v1, v2 int32 var l, v8 Tssize_t - var ret, z, v3, v4, v5, v7 uintptr + var ret, z, v3, v4 uintptr var v6 bool - _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v5, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, ret, z, v1, v2, v3, v4, v6, v8 ret = uintptr(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -136943,21 +136943,21 @@ func Xfgetln(tls *TLS, f uintptr, plen uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) } Xungetc(tls, v2, f) if v6 = (*TFILE)(unsafe.Pointer(f)).Frend != 0; v6 { - v5 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) - z = v5 + v3 = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) + z = v3 } - if v6 && v5 != 0 { + if v6 && v3 != 0 { ret = (*TFILE)(unsafe.Pointer(f)).Frpos - z++ - v7 = z - *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v7) - int64(ret)) + z = z + 1 + v3 = z + *(*Tsize_t)(unsafe.Pointer(plen)) = Uint64FromInt64(int64(v3) - int64(ret)) (*TFILE)(unsafe.Pointer(f)).Frpos = z } else { *(*[1]Tsize_t)(unsafe.Pointer(bp)) = [1]Tsize_t{} @@ -136994,13 +136994,13 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var k Tsize_t - var p, z, v6, v7, v9 uintptr + var p, z, v6, v7 uintptr var v2 int64 var v3 uint64 var v8 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, k, p, z, v1, v2, v3, v4, v6, v7, v8 p = s if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -137019,7 +137019,7 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { *(*uint8)(unsafe.Pointer(s)) = uint8(0) return s } - n-- + n = n - 1 for n != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { z = Xmemchr(tls, (*TFILE)(unsafe.Pointer(f)).Frpos, int32('\n'), Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Frend)-int64((*TFILE)(unsafe.Pointer(f)).Frpos))) @@ -137037,8 +137037,8 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { k = v3 Xmemcpy(tls, p, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - p += uintptr(k) - n = int32(uint64(n) - k) + p = p + uintptr(k) + n = Int32FromUint64(uint64(n) - k) if z != 0 || !(n != 0) { break } @@ -137046,24 +137046,24 @@ func Xfgets(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 < 0 { + v1 = v4 + c = v1 + if v1 < 0 { if p == s || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { s = uintptr(0) } break } - n-- + n = n - 1 v8 = Uint8FromInt32(c) - v9 = p - p++ - *(*uint8)(unsafe.Pointer(v9)) = v8 + v6 = p + p = p + 1 + *(*uint8)(unsafe.Pointer(v6)) = v8 if Int32FromUint8(v8) == int32('\n') { break } @@ -137110,7 +137110,7 @@ func ___fgetwc_unlocked_internal(tls *TLS, f uintptr) (r Twint_t) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } else { v2 = X__uflow(tls, f) @@ -137200,22 +137200,22 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { trc("tls=%v s=%v n=%v f=%v, (%v:)", tls, s, n, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v2 int32 + var __need_unlock, v1 int32 var c Twint_t - var p, v4, v5 uintptr - _, _, _, _, _, _, _ = __need_unlock, c, p, v1, v2, v4, v5 + var p, v4 uintptr + _, _, _, _, _ = __need_unlock, c, p, v1, v4 p = s v1 = n - n-- + n = n - 1 if !(v1 != 0) { return s } if AtomicLoadPInt32(f+140) >= 0 { - v2 = ___lockfile(tls, f) + v1 = ___lockfile(tls, f) } else { - v2 = 0 + v1 = 0 } - __need_unlock = v2 + __need_unlock = v1 for { if !(n != 0) { break @@ -137233,7 +137233,7 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { goto _3 _3: ; - n-- + n = n - 1 } *(*Twchar_t)(unsafe.Pointer(p)) = 0 if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { @@ -137243,11 +137243,11 @@ func Xfgetws(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { ___unlockfile(tls, f) } if p == s { - v5 = UintptrFromInt32(0) + v4 = UintptrFromInt32(0) } else { - v5 = s + v4 = s } - return v5 + return v4 } func Xfgetws_unlocked(tls *TLS, s uintptr, n int32, f uintptr) (r uintptr) { @@ -137361,7 +137361,7 @@ func _mread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } Xmemcpy(tls, buf, (*Tcookie)(unsafe.Pointer(c)).Fbuf+uintptr((*Tcookie)(unsafe.Pointer(c)).Fpos), len1) *(*Tsize_t)(unsafe.Pointer(c)) += len1 - rem -= len1 + rem = rem - len1 if rem > (*TFILE)(unsafe.Pointer(f)).Fbuf_size { rem = (*TFILE)(unsafe.Pointer(f)).Fbuf_size } @@ -137524,11 +137524,11 @@ type Tcookie_FILE = struct { } func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { - var fc, v2, v3, v5 uintptr + var fc, v2, v3 uintptr var len2, readlen, remain, v1 Tsize_t var ret Tssize_t var v4 int32 - _, _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _, _, _ = fc, len2, readlen, remain, ret, v1, v2, v3, v4 fc = (*TFILE)(unsafe.Pointer(f)).Fcookie ret = int64(-int32(1)) remain = len1 @@ -137542,8 +137542,8 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if ret <= 0 { goto bail } - readlen += Uint64FromInt64(ret) - remain -= Uint64FromInt64(ret) + readlen = readlen + Uint64FromInt64(ret) + remain = remain - Uint64FromInt64(ret) } if !((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0) || remain > BoolUint64(!!((*TFILE)(unsafe.Pointer(f)).Fbuf_size != 0)) { return readlen @@ -137555,10 +137555,10 @@ func _cookieread(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { } (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Frpos + uintptr(ret) v1 = readlen - readlen++ + readlen = readlen + 1 v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 *(*uint8)(unsafe.Pointer(buf + uintptr(v1))) = *(*uint8)(unsafe.Pointer(v2)) return readlen goto bail @@ -137570,9 +137570,9 @@ bail: v4 = int32(F_ERR) } *(*uint32)(unsafe.Pointer(f)) |= Uint32FromInt32(v4) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Frend = v5 - (*TFILE)(unsafe.Pointer(f)).Frpos = v5 + v2 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Frend = v2 + (*TFILE)(unsafe.Pointer(f)).Frpos = v2 return readlen } @@ -137700,10 +137700,10 @@ func Xfprintf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_putc(tls *TLS, c int32, f uintptr) (r int32) { - var old, v1, v10, v13, v16, v17, v2, v4, v9 int32 - var v15, v6, v7, v8 uintptr + var old, v1, v10, v2, v4, v9 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, v1, v10, v13, v15, v16, v17, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _ = old, v1, v10, v2, v4, v5, v6, v7, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -137720,47 +137720,47 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 140 + c = v1 + v6 = f + 140 for { - old = AtomicLoadPInt32(v8) + old = AtomicLoadPInt32(v6) goto _12 _12: ; - v9 = old + v1 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1551) - v10 = v9 + v2 = v1 goto _11 _11: ; - if !(v10 != old) { + if !(v2 != old) { break } } - v13 = old + v4 = old goto _14 _14: - if v13&int32(MAYBE_WAITERS) != 0 { - v15 = f + 140 - v16 = int32(1) - v17 = int32(1) - if v17 != 0 { - v17 = int32(FUTEX_PRIVATE) + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 140 + v9 = int32(1) + v10 = int32(1) + if v10 != 0 { + v10 = int32(FUTEX_PRIVATE) } - if v16 < Int32FromInt32(0) { - v16 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v16)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v16)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)|v10), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -137782,7 +137782,7 @@ func Xfputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -137840,7 +137840,7 @@ func X__fputwc_unlocked(tls *TLS, c Twchar_t, f uintptr) (r Twint_t) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -137970,8 +137970,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r var __need_unlock, v1 int32 var dest uintptr var k, l, len1 Tsize_t - var v2, v4 uint64 - _, _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2, v4 + var v2 uint64 + _, _, _, _, _, _, _ = __need_unlock, dest, k, l, len1, v1, v2 dest = destv len1 = size * nmemb l = len1 @@ -137995,8 +137995,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r k = v2 Xmemcpy(tls, dest, (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - dest += uintptr(k) - l -= k + dest = dest + uintptr(k) + l = l - k } /* Read the remainder directly */ for { @@ -138004,11 +138004,11 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r break } if X__toread(tls, f) != 0 { - v4 = uint64(0) + v2 = uint64(0) } else { - v4 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) + v2 = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fread})))(tls, f, dest, l) } - k = v4 + k = v2 if !(k != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138018,8 +138018,8 @@ func Xfread(tls *TLS, destv uintptr, size Tsize_t, nmemb Tsize_t, f uintptr) (r goto _3 _3: ; - l -= k - dest += uintptr(k) + l = l - k + dest = dest + uintptr(k) } if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138063,7 +138063,7 @@ func Xfreopen(tls *TLS, filename uintptr, mode uintptr, f uintptr) (r uintptr) { if fl&int32(O_CLOEXEC) != 0 { X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFD)), int64(Int32FromInt32(FD_CLOEXEC))) } - fl &= ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) + fl = fl & ^(Int32FromInt32(O_CREAT) | Int32FromInt32(O_EXCL) | Int32FromInt32(O_CLOEXEC)) if X__syscall_ret(tls, Uint64FromInt64(X__syscall3(tls, int64(SYS_fcntl), int64((*TFILE)(unsafe.Pointer(f)).Ffd), int64(Int32FromInt32(F_SETFL)), int64(fl)))) < 0 { goto fail } @@ -138130,8 +138130,8 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) trc("tls=%v f=%v off=%v whence=%v, (%v:)", tls, f, off, whence, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v2, v3 uintptr - _, _, _ = v1, v2, v3 + var v1, v2 uintptr + _, _ = v1, v2 /* Fail immediately for invalid whence argument. */ if whence != int32(1) && whence != 0 && whence != int32(2) { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) @@ -138139,7 +138139,7 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) } /* Adjust relative offset for unread data in buffer, if any. */ if whence == int32(1) && (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - off -= int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos) + off = off - (int64((*TFILE)(unsafe.Pointer(f)).Frend) - int64((*TFILE)(unsafe.Pointer(f)).Frpos)) } /* Flush write buffer, and report error on failure. */ if (*TFILE)(unsafe.Pointer(f)).Fwpos != (*TFILE)(unsafe.Pointer(f)).Fwbase { @@ -138159,9 +138159,9 @@ func X__fseeko_unlocked(tls *TLS, f uintptr, off Toff_t, whence int32) (r int32) return -int32(1) } /* If seek succeeded, file is seekable and we discard read buffer. */ - v3 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Frend = v3 - (*TFILE)(unsafe.Pointer(f)).Frpos = v3 + v1 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Frend = v1 + (*TFILE)(unsafe.Pointer(f)).Frpos = v1 *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) return 0 } @@ -138238,10 +138238,10 @@ func X__ftello_unlocked(tls *TLS, f uintptr) (r Toff_t) { } /* Adjust for data in buffer. */ if (*TFILE)(unsafe.Pointer(f)).Frend != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Frend)) } else { if (*TFILE)(unsafe.Pointer(f)).Fwbase != 0 { - pos += int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase) + pos = pos + (int64((*TFILE)(unsafe.Pointer(f)).Fwpos) - int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) } } return pos @@ -138348,10 +138348,10 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) defer func() { trc("-> %v", r) }() } - var owner, tid, v1, v2, v3 int32 + var owner, tid, v1, v2 int32 var self Tpthread_t var v5 bool - _, _, _, _, _, _, _ = owner, self, tid, v1, v2, v3, v5 + _, _, _, _, _, _ = owner, self, tid, v1, v2, v5 self = uintptr(___get_tp(tls)) tid = (*t__pthread)(unsafe.Pointer(self)).Ftid owner = AtomicLoadPInt32(f + 140) @@ -138359,7 +138359,7 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Flockcount == int64(0x7fffffffffffffff) { return -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Flockcount++ + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount + 1 return 0 } if owner < 0 { @@ -138368,17 +138368,17 @@ func Xftrylockfile(tls *TLS, f uintptr) (r int32) { AtomicStorePInt32(f+140, v1) } if v5 = owner != 0; !v5 { - v2 = 0 + v1 = 0 // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1590) - v3 = v2 + v2 = v1 goto _4 _4: } - if v5 || v3 != 0 { + if v5 || v2 != 0 { return -int32(1) } X__register_locked_file(tls, f, self) @@ -138394,7 +138394,7 @@ func Xfunlockfile(tls *TLS, f uintptr) { (*TFILE)(unsafe.Pointer(f)).Flockcount = 0 ___unlockfile(tls, f) } else { - (*TFILE)(unsafe.Pointer(f)).Flockcount-- + (*TFILE)(unsafe.Pointer(f)).Flockcount = (*TFILE)(unsafe.Pointer(f)).Flockcount - 1 } } @@ -138403,9 +138403,9 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { trc("tls=%v f=%v mode=%v, (%v:)", tls, f, mode, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, v1, v3, v4 int32 + var __need_unlock, v1, v3 int32 var v2 Tlocale_t - _, _, _, _, _ = __need_unlock, v1, v2, v3, v4 + _, _, _, _ = __need_unlock, v1, v2, v3 if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) } else { @@ -138428,11 +138428,11 @@ func Xfwide(tls *TLS, f uintptr, mode int32) (r int32) { } if !((*TFILE)(unsafe.Pointer(f)).Fmode != 0) { if mode > 0 { - v4 = int32(1) + v1 = int32(1) } else { - v4 = -int32(1) + v1 = -int32(1) } - (*TFILE)(unsafe.Pointer(f)).Fmode = v4 + (*TFILE)(unsafe.Pointer(f)).Fmode = v1 } } mode = (*TFILE)(unsafe.Pointer(f)).Fmode @@ -138480,15 +138480,15 @@ func X__fwritex(tls *TLS, s uintptr, l Tsize_t, f uintptr) (r Tsize_t) { goto _1 _1: ; - i-- + i = i - 1 } if i != 0 { n = (*(*func(*TLS, uintptr, uintptr, Tsize_t) Tsize_t)(unsafe.Pointer(&struct{ uintptr }{(*TFILE)(unsafe.Pointer(f)).Fwrite})))(tls, f, s, i) if n < i { return n } - s += uintptr(i) - l -= i + s = s + uintptr(i) + l = l - i } } Xmemcpy(tls, (*TFILE)(unsafe.Pointer(f)).Fwpos, s, l) @@ -138558,9 +138558,9 @@ func X__isoc99_fwscanf(tls *TLS, f uintptr, fmt uintptr, va uintptr) (r int32) { } func _locking_getc1(tls *TLS, f uintptr) (r int32) { - var c, old, v1, v12, v15, v16, v2, v4, v8, v9 int32 + var c, old, v1, v12, v2, v4, v8, v9 int32 var v14, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v15, v16, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v2, v4, v5, v6, v7, v8, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -138576,46 +138576,46 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 + c = v1 v7 = f + 140 for { old = AtomicLoadPInt32(v7) goto _11 _11: ; - v8 = old + v2 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1538) - v9 = v8 + v4 = v2 goto _10 _10: ; - if !(v9 != old) { + if !(v4 != old) { break } } - v12 = old + v8 = old goto _13 _13: - if v12&int32(MAYBE_WAITERS) != 0 { + if v8&int32(MAYBE_WAITERS) != 0 { v14 = f + 140 - v15 = int32(1) - v16 = int32(1) - if v16 != 0 { - v16 = int32(FUTEX_PRIVATE) + v9 = int32(1) + v12 = int32(1) + if v12 != 0 { + v12 = int32(FUTEX_PRIVATE) } - if v15 < Int32FromInt32(0) { - v15 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v15)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v15)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -138634,7 +138634,7 @@ func Xgetc(tls *TLS, f1 uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138667,7 +138667,7 @@ func Xgetc_unlocked(tls *TLS, f uintptr) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v3 = f + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, f) @@ -138692,9 +138692,9 @@ func Xfgetc_unlocked(tls *TLS, f uintptr) (r int32) { } func _locking_getc2(tls *TLS, f uintptr) (r int32) { - var c, old, v1, v12, v15, v16, v2, v4, v8, v9 int32 + var c, old, v1, v12, v2, v4, v8, v9 int32 var v14, v5, v6, v7 uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v15, v16, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _ = c, old, v1, v12, v14, v2, v4, v5, v6, v7, v8, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -138710,46 +138710,46 @@ _3: if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ - v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { - v4 = X__uflow(tls, f) + v1 = X__uflow(tls, f) } - c = v4 + c = v1 v7 = f + 140 for { old = AtomicLoadPInt32(v7) goto _11 _11: ; - v8 = old + v2 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1538) - v9 = v8 + v4 = v2 goto _10 _10: ; - if !(v9 != old) { + if !(v4 != old) { break } } - v12 = old + v8 = old goto _13 _13: - if v12&int32(MAYBE_WAITERS) != 0 { + if v8&int32(MAYBE_WAITERS) != 0 { v14 = f + 140 - v15 = int32(1) - v16 = int32(1) - if v16 != 0 { - v16 = int32(FUTEX_PRIVATE) + v9 = int32(1) + v12 = int32(1) + if v12 != 0 { + v12 = int32(FUTEX_PRIVATE) } - if v15 < Int32FromInt32(0) { - v15 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v16), int64(v15)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v15)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)|v12), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v14), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -138768,7 +138768,7 @@ func Xgetchar(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(v1)).Frpos != (*TFILE)(unsafe.Pointer(v1)).Frend { v6 = v1 + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = X__uflow(tls, v1) @@ -138793,7 +138793,7 @@ func Xgetchar_unlocked(tls *TLS) (r int32) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v3 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v2))) } else { v1 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138806,12 +138806,12 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize trc("tls=%v s=%v n=%v delim=%v f=%v, (%v:)", tls, s, n, delim, f, origin(2)) defer func() { trc("-> %v", r) }() } - var __need_unlock, c, v1, v4, v5 int32 + var __need_unlock, c, v1, v4 int32 var i, k, m, v11 Tsize_t - var tmp, z, v6, v7, v8, v9 uintptr + var tmp, z, v6, v7 uintptr var v10 uint8 var v3 int64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, c, i, k, m, tmp, z, v1, v10, v11, v3, v4, v6, v7 i = uint64(0) if AtomicLoadPInt32(f+140) >= 0 { v1 = ___lockfile(tls, f) @@ -138847,7 +138847,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if i+k >= *(*Tsize_t)(unsafe.Pointer(n)) { m = i + k + uint64(2) if !(z != 0) && m < Uint64FromUint64(0xffffffffffffffff)/Uint64FromInt32(4) { - m += m / uint64(2) + m = m + m/uint64(2) } tmp = Xrealloc(tls, *(*uintptr)(unsafe.Pointer(s)), m) if !(tmp != 0) { @@ -138874,7 +138874,7 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if k != 0 { Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(s))+uintptr(i), (*TFILE)(unsafe.Pointer(f)).Frpos, k) *(*uintptr)(unsafe.Pointer(f + 8)) += uintptr(k) - i += k + i = i + k } if z != 0 { break @@ -138882,14 +138882,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend { v7 = f + 8 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ - v5 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v6))) } else { - v5 = X__uflow(tls, f) + v4 = X__uflow(tls, f) } - v4 = v5 - c = v4 - if v4 == -int32(1) { + v1 = v4 + c = v1 + if v1 == -int32(1) { if !(i != 0) || !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_EOF) != 0) { if __need_unlock != 0 { ___unlockfile(tls, f) @@ -138901,14 +138901,14 @@ func Xgetdelim(tls *TLS, s uintptr, n uintptr, delim int32, f uintptr) (r Tssize /* If the byte read by getc won't fit without growing the * output buffer, push it back for next iteration. */ if i+uint64(1) >= *(*Tsize_t)(unsafe.Pointer(n)) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - *(*uint8)(unsafe.Pointer(v8)) = Uint8FromInt32(c) + v7 = f + 8 + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) - 1 + v6 = *(*uintptr)(unsafe.Pointer(v7)) + *(*uint8)(unsafe.Pointer(v6)) = Uint8FromInt32(c) } else { v10 = Uint8FromInt32(c) v11 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(s)) + uintptr(v11))) = v10 if Int32FromUint8(v10) == delim { break @@ -138960,7 +138960,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { if (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frpos != (*TFILE)(unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdin_FILE)))).Frend { v5 = uintptr(unsafe.Pointer(&X__stdin_FILE)) + 8 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) } else { v3 = X__uflow(tls, uintptr(unsafe.Pointer(&X__stdin_FILE))) @@ -138971,7 +138971,7 @@ func Xgets(tls *TLS, s uintptr) (r uintptr) { break } v6 = i - i++ + i = i + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v6))) = Uint8FromInt32(c) } *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) @@ -139150,17 +139150,17 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(1304)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(1)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(1)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139176,9 +139176,9 @@ func Xopen_memstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Tms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*uint8)(unsafe.Pointer(buf)) = uint8(0) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Tms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139294,17 +139294,17 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { trc("tls=%v bufp=%v sizep=%v, (%v:)", tls, bufp, sizep, origin(2)) defer func() { trc("-> %v", r) }() } - var buf, f, v1, v2, v6 uintptr + var buf, f, v1 uintptr var v3, v4, v5 Tsize_t - _, _, _, _, _, _, _, _ = buf, f, v1, v2, v3, v4, v5, v6 + _, _, _, _, _, _ = buf, f, v1, v3, v4, v5 v1 = Xmalloc(tls, uint64(296)) f = v1 if !(v1 != 0) { return uintptr(0) } - v2 = Xmalloc(tls, uint64(4)) - buf = v2 - if !(v2 != 0) { + v1 = Xmalloc(tls, uint64(4)) + buf = v1 + if !(v1 != 0) { Xfree(tls, f) return uintptr(0) } @@ -139320,9 +139320,9 @@ func Xopen_wmemstream(tls *TLS, bufp uintptr, sizep uintptr) (r uintptr) { v3 = v4 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Flen1 = v3 (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fpos = v3 - v6 = buf - *(*uintptr)(unsafe.Pointer(bufp)) = v6 - (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v6 + v1 = buf + *(*uintptr)(unsafe.Pointer(bufp)) = v1 + (*Twms_FILE)(unsafe.Pointer(f)).Fc.Fbuf = v1 *(*Twchar_t)(unsafe.Pointer(buf)) = 0 (*Twms_FILE)(unsafe.Pointer(f)).Ff.Fflags = uint32(F_NORD) (*Twms_FILE)(unsafe.Pointer(f)).Ff.Ffd = -int32(1) @@ -139413,10 +139413,10 @@ func Xprintf(tls *TLS, fmt uintptr, va uintptr) (r int32) { } func _locking_putc1(tls *TLS, c int32, f uintptr) (r int32) { - var old, v1, v10, v13, v16, v17, v2, v4, v9 int32 - var v15, v6, v7, v8 uintptr + var old, v1, v10, v2, v4, v9 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, v1, v10, v13, v15, v16, v17, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _ = old, v1, v10, v2, v4, v5, v6, v7, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -139433,47 +139433,47 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 140 + c = v1 + v6 = f + 140 for { - old = AtomicLoadPInt32(v8) + old = AtomicLoadPInt32(v6) goto _12 _12: ; - v9 = old + v1 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1551) - v10 = v9 + v2 = v1 goto _11 _11: ; - if !(v10 != old) { + if !(v2 != old) { break } } - v13 = old + v4 = old goto _14 _14: - if v13&int32(MAYBE_WAITERS) != 0 { - v15 = f + 140 - v16 = int32(1) - v17 = int32(1) - if v17 != 0 { - v17 = int32(FUTEX_PRIVATE) + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 140 + v9 = int32(1) + v10 = int32(1) + if v10 != 0 { + v10 = int32(FUTEX_PRIVATE) } - if v16 < Int32FromInt32(0) { - v16 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v16)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v16)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)|v10), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -139495,7 +139495,7 @@ func Xputc(tls *TLS, c1 int32, f1 uintptr) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139531,7 +139531,7 @@ func Xputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { v2 = Uint8FromInt32(c) v4 = f + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139557,10 +139557,10 @@ func Xfputc_unlocked(tls *TLS, c int32, f uintptr) (r int32) { } func _locking_putc2(tls *TLS, c int32, f uintptr) (r int32) { - var old, v1, v10, v13, v16, v17, v2, v4, v9 int32 - var v15, v6, v7, v8 uintptr + var old, v1, v10, v2, v4, v9 int32 + var v6, v7 uintptr var v5 uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = old, v1, v10, v13, v15, v16, v17, v2, v4, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _ = old, v1, v10, v2, v4, v5, v6, v7, v9 v1 = 0 // __asm__ __volatile__ ( // @@ -139577,47 +139577,47 @@ _3: v5 = Uint8FromInt32(c) v7 = f + 40 v6 = *(*uintptr)(unsafe.Pointer(v7)) - *(*uintptr)(unsafe.Pointer(v7))++ + *(*uintptr)(unsafe.Pointer(v7)) = *(*uintptr)(unsafe.Pointer(v7)) + 1 *(*uint8)(unsafe.Pointer(v6)) = v5 - v4 = Int32FromUint8(v5) + v1 = Int32FromUint8(v5) } else { - v4 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) + v1 = X__overflow(tls, f, Int32FromUint8(Uint8FromInt32(c))) } - c = v4 - v8 = f + 140 + c = v1 + v6 = f + 140 for { - old = AtomicLoadPInt32(v8) + old = AtomicLoadPInt32(v6) goto _12 _12: ; - v9 = old + v1 = old // __asm__ __volatile__ ( // // "cs %0, %2, %1" // : "+d"(t), "+Q"(*p) : "d"(s) : "memory", "cc"); X__assert_fail(tls, __ccgo_ts+212, __ccgo_ts+247, 4, __ccgo_ts+1551) - v10 = v9 + v2 = v1 goto _11 _11: ; - if !(v10 != old) { + if !(v2 != old) { break } } - v13 = old + v4 = old goto _14 _14: - if v13&int32(MAYBE_WAITERS) != 0 { - v15 = f + 140 - v16 = int32(1) - v17 = int32(1) - if v17 != 0 { - v17 = int32(FUTEX_PRIVATE) + if v4&int32(MAYBE_WAITERS) != 0 { + v7 = f + 140 + v9 = int32(1) + v10 = int32(1) + if v10 != 0 { + v10 = int32(FUTEX_PRIVATE) } - if v16 < Int32FromInt32(0) { - v16 = int32(INT_MAX) + if v9 < Int32FromInt32(0) { + v9 = int32(INT_MAX) } - _ = X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)|v17), int64(v16)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v15), int64(Int32FromInt32(FUTEX_WAKE)), int64(v16)) != 0 + _ = X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)|v10), int64(v9)) != int64(-int32(ENOSYS)) || X__syscall3(tls, int64(SYS_futex), int64(v7), int64(Int32FromInt32(FUTEX_WAKE)), int64(v9)) != 0 } return c } @@ -139639,7 +139639,7 @@ func Xputchar(tls *TLS, c1 int32) (r int32) { v6 = Uint8FromInt32(v1) v8 = v2 + 40 v7 = *(*uintptr)(unsafe.Pointer(v8)) - *(*uintptr)(unsafe.Pointer(v8))++ + *(*uintptr)(unsafe.Pointer(v8)) = *(*uintptr)(unsafe.Pointer(v8)) + 1 *(*uint8)(unsafe.Pointer(v7)) = v6 v5 = Int32FromUint8(v6) } else { @@ -139667,7 +139667,7 @@ func Xputchar_unlocked(tls *TLS, c int32) (r int32) { v2 = Uint8FromInt32(c) v4 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(v3)) = v2 v1 = Int32FromUint8(v2) } else { @@ -139697,7 +139697,7 @@ func Xputs(tls *TLS, s uintptr) (r1 int32) { v3 = Uint8FromInt32(Int32FromUint8('\n')) v5 = uintptr(unsafe.Pointer(&X__stdout_FILE)) + 40 v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) + 1 *(*uint8)(unsafe.Pointer(v4)) = v3 v2 = Int32FromUint8(v3) } else { @@ -140033,7 +140033,7 @@ func Xtempnam(tls *TLS, dir uintptr, pfx uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140068,7 +140068,7 @@ func Xtmpfile(tls *TLS) (r uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140104,7 +140104,7 @@ func Xtmpnam(tls *TLS, buf uintptr) (r1 uintptr) { goto _1 _1: ; - try++ + try = try + 1 } return uintptr(0) } @@ -140138,7 +140138,7 @@ func Xungetc(tls *TLS, c int32, f uintptr) (r int32) { return -int32(1) } v3 = f + 8 - *(*uintptr)(unsafe.Pointer(v3))-- + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) - 1 v2 = *(*uintptr)(unsafe.Pointer(v3)) *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(c) *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) @@ -140155,12 +140155,12 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } bp := tls.Alloc(16) defer tls.Free(16) - var __need_unlock, l, v1, v2 int32 + var __need_unlock, l, v1 int32 var loc Tlocale_t - var ploc, v4, v5, p6 uintptr + var ploc, v4, v5 uintptr var v3 bool var _ /* mbc at bp+0 */ [4]uint8 - _, _, _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v2, v3, v4, v5, p6 + _, _, _, _, _, _, _, _ = __need_unlock, l, loc, ploc, v1, v3, v4, v5 ploc = uintptr(___get_tp(tls)) + 168 loc = *(*Tlocale_t)(unsafe.Pointer(ploc)) if AtomicLoadPInt32(f+140) >= 0 { @@ -140177,10 +140177,10 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { X__toread(tls, f) } if v3 = !((*TFILE)(unsafe.Pointer(f)).Frpos != 0) || c == uint32(0xffffffff); !v3 { - v2 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) - l = v2 + v1 = Int32FromUint64(Xwcrtomb(tls, bp, Int32FromUint32(c), uintptr(0))) + l = v1 } - if v3 || v2 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { + if v3 || v1 < 0 || (*TFILE)(unsafe.Pointer(f)).Frpos < (*TFILE)(unsafe.Pointer(f)).Fbuf-uintptr(UNGET)+uintptr(l) { if __need_unlock != 0 { ___unlockfile(tls, f) } @@ -140189,13 +140189,13 @@ func Xungetwc(tls *TLS, c Twint_t, f uintptr) (r Twint_t) { } if BoolInt32(c < uint32(128)) != 0 { v5 = f + 8 - *(*uintptr)(unsafe.Pointer(v5))-- + *(*uintptr)(unsafe.Pointer(v5)) = *(*uintptr)(unsafe.Pointer(v5)) - 1 v4 = *(*uintptr)(unsafe.Pointer(v5)) *(*uint8)(unsafe.Pointer(v4)) = uint8(c) } else { - p6 = f + 8 - *(*uintptr)(unsafe.Pointer(p6)) -= uintptr(l) - Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(p6)), bp, Uint64FromInt32(l)) + v4 = f + 8 + *(*uintptr)(unsafe.Pointer(v4)) -= uintptr(l) + Xmemcpy(tls, *(*uintptr)(unsafe.Pointer(v4)), bp, Uint64FromInt32(l)) } *(*uint32)(unsafe.Pointer(f)) &= Uint32FromInt32(^Int32FromInt32(F_EOF)) if __need_unlock != 0 { @@ -140471,7 +140471,7 @@ func _pad3(tls *TLS, f uintptr, c uint8, w int32, l int32, fl int32) { goto _2 _2: ; - l = int32(uint64(l) - Uint64FromInt64(256)) + l = Int32FromUint64(uint64(l) - Uint64FromInt64(256)) } _out(tls, f, bp, Uint64FromInt32(l)) } @@ -140485,13 +140485,13 @@ func _fmt_x(tls *TLS, x Tuintmax_t, s uintptr, lower int32) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x&uint64(15)]) | lower) goto _1 _1: ; - x >>= uint64(4) + x = x >> uint64(4) } return s } @@ -140503,45 +140503,45 @@ func _fmt_o(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { if !(x != 0) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x&uint64(7)) goto _1 _1: ; - x >>= uint64(3) + x = x >> uint64(3) } return s } func _fmt_u(tls *TLS, x Tuintmax_t, s uintptr) (r uintptr) { var y uint64 - var v2, v4 uintptr - _, _, _ = y, v2, v4 + var v2 uintptr + _, _ = y, v2 for { if !(x > Uint64FromUint64(2)*Uint64FromInt64(0x7fffffffffffffff)+Uint64FromInt32(1)) { break } - s-- + s = s - 1 v2 = s *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + x%uint64(10)) goto _1 _1: ; - x /= uint64(10) + x = x / uint64(10) } y = x for { if !(y != 0) { break } - s-- - v4 = s - *(*uint8)(unsafe.Pointer(v4)) = uint8(uint64('0') + y%uint64(10)) + s = s - 1 + v2 = s + *(*uint8)(unsafe.Pointer(v2)) = uint8(uint64('0') + y%uint64(10)) goto _3 _3: ; - y /= uint64(10) + y = y / uint64(10) } return s } @@ -140556,13 +140556,13 @@ type Tcompiler_defines_long_double_incorrectly = [1]uint8 func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32) (r1 int32) { bp := tls.Alloc(560) defer tls.Free(560) - var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v10, v11, v13, v14, v15, v17, v18, v19, v20, v21, v24, v27, v28, v31, v32, v43, v44, v46, v48, v49, v5, v51, v54, v55, v56, v6 uintptr + var a, b, d, ebuf, estr, prefix, r, s, s1, s2, s3, s4, z, v5, v6 uintptr var carry, carry1, rm, x2 Tuint32_t - var e, i, j, l, need, pl, re, sh, sh1, x, v12, v16, v22, v25, v42, v45, v52, v58, v7, v8, v9 int32 + var e, i, j, l, need, pl, re, sh, sh1, x, v7 int32 var round, round1, small float64 var x1 Tuint64_t - var v1, v3 uint64 - var v36, v37, v38, v39, v40, v41, v57 int64 + var v1 uint64 + var v36, v37, v38 int64 var _ /* __u at bp+0 */ struct { F__i [0]uint64 F__f float64 @@ -140571,7 +140571,7 @@ func _fmt_fp(tls *TLS, f uintptr, y float64, w int32, p int32, fl int32, t int32 var _ /* buf at bp+516 */ [22]uint8 var _ /* e2 at bp+512 */ int32 var _ /* ebuf0 at bp+538 */ [12]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v24, v25, v27, v28, v3, v31, v32, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v48, v49, v5, v51, v52, v54, v55, v56, v57, v58, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, b, carry, carry1, d, e, ebuf, estr, i, j, l, need, pl, prefix, r, re, rm, round, round1, s, s1, s2, s3, s4, sh, sh1, small, x, x1, x2, z, v1, v36, v37, v38, v5, v6, v7 *(*int32)(unsafe.Pointer(bp + 512)) = 0 prefix = __ccgo_ts + 1616 ebuf = bp + 538 + uintptr(Uint64FromInt32(3)*Uint64FromInt64(4)) @@ -140584,21 +140584,21 @@ _2: y = -y } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(3) + prefix = prefix + uintptr(3) } else { if Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(6) + prefix = prefix + uintptr(6) } else { - prefix++ + prefix = prefix + 1 pl = Int32FromInt32(0) } } } *(*float64)(unsafe.Pointer(bp)) = y - v3 = *(*uint64)(unsafe.Pointer(bp)) + v1 = *(*uint64)(unsafe.Pointer(bp)) goto _4 _4: - if !(BoolInt32(v3&(-Uint64FromUint64(1)>>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<>Int32FromInt32(1)) < Uint64FromUint64(0x7ff)<= Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4)-Int32FromInt32(1) { re = 0 } else { re = Int32FromInt32(LDBL_MANT_DIG)/Int32FromInt32(4) - Int32FromInt32(1) - p } if re != 0 { - round *= float64(Int32FromInt32(1) << (Int32FromInt32(LDBL_MANT_DIG) % Int32FromInt32(4))) + round = round * float64(Int32FromInt32(1)<<(Int32FromInt32(LDBL_MANT_DIG)%Int32FromInt32(4))) for { - v8 = re - re-- - if !(v8 != 0) { + v7 = re + re = re - 1 + if !(v7 != 0) { break } - round *= Float64FromInt32(16) + round = round * Float64FromInt32(16) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { y = -y - y -= round - y += round + y = y - round + y = y + round y = -y } else { - y += round - y -= round + y = y + round + y = y - round } } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v9 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } else { - v9 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - estr = _fmt_u(tls, Uint64FromInt32(v9), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) if estr == ebuf { - estr-- - v10 = estr - *(*uint8)(unsafe.Pointer(v10)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v11 = estr + estr = estr - 1 + v5 = estr if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v12 = int32('-') + v7 = int32('-') } else { - v12 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v11)) = Uint8FromInt32(v12) - estr-- - v13 = estr - *(*uint8)(unsafe.Pointer(v13)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t + (Int32FromUint8('p') - Int32FromUint8('a'))) s = bp + 516 for cond := true; cond; cond = y != 0 { x = int32(y) - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v14)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(Int32FromUint8(_xdigits1[x]) | t&int32(32)) y = float64(Float64FromInt32(16) * (y - float64(x))) if int64(s)-t__predefined_ptrdiff_t(bp+516) == int64(1) && (y != 0 || p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { - v15 = s - s++ - *(*uint8)(unsafe.Pointer(v15)) = uint8('.') + v5 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v5)) = uint8('.') } } if int64(p) > int64(Int32FromInt32(INT_MAX)-Int32FromInt32(2))-(int64(ebuf)-int64(estr))-int64(pl) { @@ -140710,46 +140710,46 @@ _4: _out(tls, f, estr, Uint64FromInt64(int64(ebuf)-int64(estr))) _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v16 = w + v7 = w } else { - v16 = pl + l + v7 = pl + l } - return v16 + return v7 } if p < 0 { p = int32(6) } if y != 0 { - y *= Float64FromFloat64(2.68435456e+08) - *(*int32)(unsafe.Pointer(bp + 512)) -= int32(28) + y = y * Float64FromFloat64(2.68435456e+08) + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - int32(28) } if *(*int32)(unsafe.Pointer(bp + 512)) < 0 { - v18 = bp + 8 - z = v18 - v17 = v18 - r = v17 - a = v17 + v6 = bp + 8 + z = v6 + v5 = v6 + r = v5 + a = v5 } else { - v20 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 - z = v20 - v19 = v20 - r = v19 - a = v19 + v6 = bp + 8 + uintptr(Uint64FromInt64(504)/Uint64FromInt64(4))*4 - UintptrFromInt32(LDBL_MANT_DIG)*4 - UintptrFromInt32(1)*4 + z = v6 + v5 = v6 + r = v5 + a = v5 } for cond := true; cond; cond = y != 0 { *(*Tuint32_t)(unsafe.Pointer(z)) = uint32(y) - v21 = z + v5 = z z += 4 - y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v21))))) + y = float64(Float64FromInt32(1000000000) * (y - float64(*(*Tuint32_t)(unsafe.Pointer(v5))))) } for *(*int32)(unsafe.Pointer(bp + 512)) > 0 { carry = uint32(0) if int32(29) < *(*int32)(unsafe.Pointer(bp + 512)) { - v22 = int32(29) + v7 = int32(29) } else { - v22 = *(*int32)(unsafe.Pointer(bp + 512)) + v7 = *(*int32)(unsafe.Pointer(bp + 512)) } - sh = v22 + sh = v7 d = z - uintptr(1)*4 for { if !(d >= a) { @@ -140765,22 +140765,22 @@ _4: } if carry != 0 { a -= 4 - v24 = a - *(*Tuint32_t)(unsafe.Pointer(v24)) = carry + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry } for z > a && !(*(*Tuint32_t)(unsafe.Pointer(z + uintptr(-Int32FromInt32(1))*4)) != 0) { z -= 4 } - *(*int32)(unsafe.Pointer(bp + 512)) -= sh + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) - sh } for *(*int32)(unsafe.Pointer(bp + 512)) < 0 { carry1 = uint32(0) if int32(9) < -*(*int32)(unsafe.Pointer(bp + 512)) { - v25 = int32(9) + v7 = int32(9) } else { - v25 = -*(*int32)(unsafe.Pointer(bp + 512)) + v7 = -*(*int32)(unsafe.Pointer(bp + 512)) } - sh1 = v25 + sh1 = v7 need = Int32FromUint32(uint32(1) + (Uint32FromInt32(p)+Uint32FromInt32(LDBL_MANT_DIG)/Uint32FromUint32(3)+uint32(8))/uint32(9)) d = a for { @@ -140799,21 +140799,21 @@ _4: a += 4 } if carry1 != 0 { - v27 = z + v5 = z z += 4 - *(*Tuint32_t)(unsafe.Pointer(v27)) = carry1 + *(*Tuint32_t)(unsafe.Pointer(v5)) = carry1 } /* Avoid (slow!) computation past requested precision */ if t|int32(32) == int32('f') { - v28 = r + v5 = r } else { - v28 = a + v5 = a } - b = v28 + b = v5 if (int64(z)-int64(b))/4 > int64(need) { z = b + uintptr(need)*4 } - *(*int32)(unsafe.Pointer(bp + 512)) += sh1 + *(*int32)(unsafe.Pointer(bp + 512)) = *(*int32)(unsafe.Pointer(bp + 512)) + sh1 } if a < z { i = int32(10) @@ -140825,8 +140825,8 @@ _4: goto _29 _29: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } else { e = 0 @@ -140836,10 +140836,10 @@ _4: if int64(j) < int64(9)*((int64(z)-int64(r))/4-int64(1)) { /* We avoid C's broken division of negative numbers */ d = r + uintptr(1)*4 + uintptr((j+Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP))/Int32FromInt32(9)-Int32FromInt32(LDBL_MAX_EXP))*4 - j += Int32FromInt32(9) * Int32FromInt32(LDBL_MAX_EXP) - j %= int32(9) + j = j + Int32FromInt32(9)*Int32FromInt32(LDBL_MAX_EXP) + j = j % int32(9) i = int32(10) - j++ + j = j + 1 for { if !(j < int32(9)) { break @@ -140847,15 +140847,15 @@ _4: goto _30 _30: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } x2 = *(*Tuint32_t)(unsafe.Pointer(d)) % Uint32FromInt32(i) /* Are there any significant digits past j? */ if x2 != 0 || d+uintptr(1)*4 != z { round1 = Float64FromInt32(2) / Float64FromFloat64(2.22044604925031308085e-16) if *(*Tuint32_t)(unsafe.Pointer(d))/Uint32FromInt32(i)&uint32(1) != 0 || i == int32(1000000000) && d > a && *(*Tuint32_t)(unsafe.Pointer(d + uintptr(-Int32FromInt32(1))*4))&uint32(1) != 0 { - round1 += Float64FromInt32(2) + round1 = round1 + Float64FromInt32(2) } if x2 < Uint32FromInt32(i/int32(2)) { small = Float64FromFloat64(0.5) @@ -140867,23 +140867,23 @@ _4: } } if pl != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(prefix))) == int32('-') { - round1 *= float64(-Int32FromInt32(1)) - small *= float64(-Int32FromInt32(1)) + round1 = round1 * float64(-Int32FromInt32(1)) + small = small * float64(-Int32FromInt32(1)) } *(*Tuint32_t)(unsafe.Pointer(d)) -= x2 /* Decide whether to round by probing round+small */ if round1+small != round1 { *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + Uint32FromInt32(i) for *(*Tuint32_t)(unsafe.Pointer(d)) > uint32(999999999) { - v31 = d + v5 = d d -= 4 - *(*Tuint32_t)(unsafe.Pointer(v31)) = uint32(0) + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) if d < a { a -= 4 - v32 = a - *(*Tuint32_t)(unsafe.Pointer(v32)) = uint32(0) + v5 = a + *(*Tuint32_t)(unsafe.Pointer(v5)) = uint32(0) } - *(*Tuint32_t)(unsafe.Pointer(d))++ + *(*Tuint32_t)(unsafe.Pointer(d)) = *(*Tuint32_t)(unsafe.Pointer(d)) + 1 } i = int32(10) e = int32(Int64FromInt32(9) * ((int64(r) - int64(a)) / 4)) @@ -140894,8 +140894,8 @@ _4: goto _33 _33: ; - i *= int32(10) - e++ + i = i * int32(10) + e = e + 1 } } } @@ -140914,14 +140914,14 @@ _4: } if t|int32(32) == int32('g') { if !(p != 0) { - p++ + p = p + 1 } if p > e && e >= -int32(4) { - t-- - p -= e + int32(1) + t = t - 1 + p = p - (e + int32(1)) } else { - t -= int32(2) - p-- + t = t - int32(2) + p = p - 1 } if !(Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0) { /* Count trailing zeros in last place */ @@ -140935,8 +140935,8 @@ _4: goto _35 _35: ; - i *= int32(10) - j++ + i = i * int32(10) + j = j + 1 } } else { j = int32(9) @@ -140960,21 +140960,21 @@ _4: p = int32(v36) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v40 = int64(Int32FromInt32(0)) + v37 = int64(Int32FromInt32(0)) } else { - v40 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v37 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - if int64(p) < v40 { - v39 = int64(p) + if int64(p) < v37 { + v36 = int64(p) } else { if int64(Int32FromInt32(0)) > int64(9)*((int64(z)-int64(r))/4-int64(1))+int64(e)-int64(j) { - v41 = int64(Int32FromInt32(0)) + v38 = int64(Int32FromInt32(0)) } else { - v41 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) + v38 = int64(9)*((int64(z)-int64(r))/4-int64(1)) + int64(e) - int64(j) } - v39 = v41 + v36 = v38 } - p = int32(v39) + p = int32(v36) } } } @@ -140987,31 +140987,31 @@ _4: return -int32(1) } if e > 0 { - l += e + l = l + e } } else { if e < 0 { - v42 = -e + v7 = -e } else { - v42 = e + v7 = e } - estr = _fmt_u(tls, Uint64FromInt32(v42), ebuf) + estr = _fmt_u(tls, Uint64FromInt32(v7), ebuf) for int64(ebuf)-int64(estr) < int64(2) { - estr-- - v43 = estr - *(*uint8)(unsafe.Pointer(v43)) = uint8('0') + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } - estr-- - v44 = estr + estr = estr - 1 + v5 = estr if e < 0 { - v45 = int32('-') + v7 = int32('-') } else { - v45 = int32('+') + v7 = int32('+') } - *(*uint8)(unsafe.Pointer(v44)) = Uint8FromInt32(v45) - estr-- - v46 = estr - *(*uint8)(unsafe.Pointer(v46)) = Uint8FromInt32(t) + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(v7) + estr = estr - 1 + v5 = estr + *(*uint8)(unsafe.Pointer(v5)) = Uint8FromInt32(t) if int64(ebuf)-int64(estr) > int64(int32(INT_MAX)-l) { return -int32(1) } @@ -141035,15 +141035,15 @@ _4: s2 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if d != a { for s2 > bp+516 { - s2-- - v48 = s2 - *(*uint8)(unsafe.Pointer(v48)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { if s2 == bp+516+uintptr(9) { - s2-- - v49 = s2 - *(*uint8)(unsafe.Pointer(v49)) = uint8('0') + s2 = s2 - 1 + v5 = s2 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } _out(tls, f, s2, Uint64FromInt64(int64(bp+516+uintptr(9))-int64(s2))) @@ -141061,21 +141061,21 @@ _4: } s3 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) for s3 > bp+516 { - s3-- - v51 = s3 - *(*uint8)(unsafe.Pointer(v51)) = uint8('0') + s3 = s3 - 1 + v5 = s3 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if int32(9) < p { - v52 = int32(9) + v7 = int32(9) } else { - v52 = p + v7 = p } - _out(tls, f, s3, Uint64FromInt32(v52)) + _out(tls, f, s3, Uint64FromInt32(v7)) goto _50 _50: ; d += 4 - p -= int32(9) + p = p - int32(9) } _pad3(tls, f, uint8('0'), p+int32(9), int32(9), 0) } else { @@ -141089,30 +141089,30 @@ _4: } s4 = _fmt_u(tls, uint64(*(*Tuint32_t)(unsafe.Pointer(d))), bp+516+uintptr(9)) if s4 == bp+516+uintptr(9) { - s4-- - v54 = s4 - *(*uint8)(unsafe.Pointer(v54)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } if d != a { for s4 > bp+516 { - s4-- - v55 = s4 - *(*uint8)(unsafe.Pointer(v55)) = uint8('0') + s4 = s4 - 1 + v5 = s4 + *(*uint8)(unsafe.Pointer(v5)) = uint8('0') } } else { - v56 = s4 - s4++ - _out(tls, f, v56, uint64(1)) + v5 = s4 + s4 = s4 + 1 + _out(tls, f, v5, uint64(1)) if p > 0 || Uint32FromInt32(fl)&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { _out(tls, f, __ccgo_ts+598, uint64(1)) } } if int64(bp+516+UintptrFromInt32(9))-int64(s4) < int64(p) { - v57 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) + v36 = int64(bp+516+UintptrFromInt32(9)) - int64(s4) } else { - v57 = int64(p) + v36 = int64(p) } - _out(tls, f, s4, Uint64FromInt64(v57)) + _out(tls, f, s4, Uint64FromInt64(v36)) p = int32(int64(p) - (int64(bp+516+UintptrFromInt32(9)) - int64(s4))) goto _53 _53: @@ -141124,11 +141124,11 @@ _4: } _pad3(tls, f, uint8(' '), w, pl+l, Int32FromUint32(Uint32FromInt32(fl)^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > pl+l { - v58 = w + v7 = w } else { - v58 = pl + l + v7 = pl + l } - return v58 + return v7 } func _getint(tls *TLS, s uintptr) (r int32) { @@ -141147,7 +141147,7 @@ func _getint(tls *TLS, s uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(s))++ + *(*uintptr)(unsafe.Pointer(s)) = *(*uintptr)(unsafe.Pointer(s)) + 1 } return i } @@ -141155,19 +141155,19 @@ func _getint(tls *TLS, s uintptr) (r int32) { func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, nl_type uintptr) (r int32) { bp := tls.Alloc(64) defer tls.Free(64) - var a, prefix, ws, z, v35, v39, v44, v48, v8 uintptr - var argpos, cnt, l, p, pl, t, w, xp, v36, v40, v42, v43, v47, v5, v50, v6, v7 int32 + var a, prefix, ws, z, v8 uintptr + var argpos, cnt, l, p, pl, t, w, xp, v5, v6 int32 var fl, l10n, ps, st uint32 var i Tsize_t var v31 uint64 var v34 int64 - var v45, v49 bool + var v45 bool var _ /* arg at bp+8 */ Targ var _ /* buf at bp+16 */ [24]uint8 var _ /* mb at bp+48 */ [4]uint8 var _ /* s at bp+0 */ uintptr var _ /* wc at bp+40 */ [2]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v35, v36, v39, v40, v42, v43, v44, v45, v47, v48, v49, v5, v50, v6, v7, v8 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, cnt, fl, i, l, l10n, p, pl, prefix, ps, st, t, w, ws, xp, z, v31, v34, v45, v5, v6, v8 *(*uintptr)(unsafe.Pointer(bp)) = fmt l10n = uint32(0) cnt = 0 @@ -141180,7 +141180,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))) != 0) { break } @@ -141193,7 +141193,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _2 _2: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } z = *(*uintptr)(unsafe.Pointer(bp)) for { @@ -141203,8 +141203,8 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _3 _3: ; - z++ - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + z = z + 1 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } if int64(z)-int64(a) > int64(int32(INT_MAX)-cnt) { goto overflow @@ -141219,10 +141219,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2))) == int32('$') { l10n = uint32(1) argpos = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1))) - int32('0') - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { argpos = -int32(1) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read modifier flags */ fl = uint32(0) @@ -141230,11 +141230,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(uint32(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) - int32(' ')) + fl = fl | uint32(1)<<(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)))))-int32(' ')) goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } /* Read field width */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('*') { @@ -141246,7 +141246,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 1)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(3) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(3) } else { if !(l10n != 0) { if f != 0 { @@ -141255,19 +141255,19 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, v5 = 0 } w = v5 - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 } else { goto inval } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint(tls, bp) - w = v6 - if v6 < 0 { + v5 = _getint(tls, bp) + w = v5 + if v5 < 0 { goto overflow } } @@ -141280,16 +141280,16 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } else { p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + 2)))-int32('0'))*8))) } - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(4) + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(4) } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp)) += uintptr(2) + p = v5 + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + uintptr(2) } else { goto inval } @@ -141297,7 +141297,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, xp = BoolInt32(p >= 0) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) == int32('.') { - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 p = _getint(tls, bp) xp = int32(1) } else { @@ -141313,7 +141313,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } ps = st v8 = *(*uintptr)(unsafe.Pointer(bp)) - *(*uintptr)(unsafe.Pointer(bp))++ + *(*uintptr)(unsafe.Pointer(bp)) = *(*uintptr)(unsafe.Pointer(bp)) + 1 st = uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_states)) + uintptr(st)*58 + uintptr(Int32FromUint8(*(*uint8)(unsafe.Pointer(v8)))-int32('A'))))) } if !(st != 0) { @@ -141352,11 +141352,11 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, t = Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp)) + uintptr(-Int32FromInt32(1))))) /* Transform ls,lc -> S,C */ if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } /* - and 0 flags are mutually exclusive */ if fl&(Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))) != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } switch t { case int32('n'): @@ -141432,14 +141432,14 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } p = Int32FromUint64(v31) t = int32('x') - fl |= Uint32FromUint32(1) << (Int32FromUint8('#') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' ')) _12: ; _11: ; a = _fmt_x(tls, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)), z, t&int32(32)) if *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0 && fl&(Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(t >> Int32FromInt32(4)) + prefix = prefix + uintptr(t>>Int32FromInt32(4)) pl = Int32FromInt32(2) } if !(0 != 0) { @@ -141465,10 +141465,10 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*Tuintmax_t)(unsafe.Pointer(bp + 8)) = -*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))) != 0 { - prefix++ + prefix = prefix + 1 } else { if fl&(Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))) != 0 { - prefix += uintptr(2) + prefix = prefix + uintptr(2) } else { pl = 0 } @@ -141483,7 +141483,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } if xp != 0 { - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) } if !(*(*Tuintmax_t)(unsafe.Pointer(bp + 8)) != 0) && !(p != 0) { a = z @@ -141501,12 +141501,12 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ; _17: ; - v36 = Int32FromInt32(1) - p = v36 - v35 = z - uintptr(v36) - a = v35 - *(*uint8)(unsafe.Pointer(v35)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + v5 = Int32FromInt32(1) + p = v5 + v8 = z - uintptr(v5) + a = v8 + *(*uint8)(unsafe.Pointer(v8)) = uint8(*(*Tuintmax_t)(unsafe.Pointer(bp + 8))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _19: ; @@ -141520,24 +141520,24 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _18: ; if *(*uintptr)(unsafe.Pointer(bp + 8)) != 0 { - v39 = *(*uintptr)(unsafe.Pointer(bp + 8)) + v8 = *(*uintptr)(unsafe.Pointer(bp + 8)) } else { - v39 = __ccgo_ts + 1657 + v8 = __ccgo_ts + 1657 } - a = v39 + a = v8 _38: ; if p < 0 { - v40 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v40 = p + v5 = p } - z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v40))) + z = a + uintptr(Xstrnlen(tls, a, Uint64FromInt32(v5))) if p < 0 && *(*uint8)(unsafe.Pointer(z)) != 0 { goto overflow } p = int32(int64(z) - int64(a)) - fl &= ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) + fl = fl & ^(Uint32FromUint32(1) << (Int32FromUint8('0') - Int32FromUint8(' '))) goto _30 _20: ; @@ -141551,23 +141551,23 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _21: ; ws = *(*uintptr)(unsafe.Pointer(bp + 8)) - v42 = Int32FromInt32(0) - l = v42 - i = Uint64FromInt32(v42) + v5 = Int32FromInt32(0) + l = v5 + i = Uint64FromInt32(v5) for { if v45 = i < Uint64FromInt32(p) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { - v44 = ws + v8 = ws ws += 4 - v43 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v44))) - l = v43 + v6 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v6 } - if !(v45 && v43 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { + if !(v45 && v6 >= 0 && Uint64FromInt32(l) <= Uint64FromInt32(p)-i) { break } goto _41 _41: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } if l < 0 { return -int32(1) @@ -141580,28 +141580,28 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, ws = *(*uintptr)(unsafe.Pointer(bp + 8)) i = uint64(0) for { - if v49 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v49 { - v48 = ws + if v45 = i < uint64(0+Uint32FromInt32(p)) && *(*Twchar_t)(unsafe.Pointer(ws)) != 0; v45 { + v8 = ws ws += 4 - v47 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v48))) - l = v47 + v5 = Xwctomb(tls, bp+48, *(*Twchar_t)(unsafe.Pointer(v8))) + l = v5 } - if !(v49 && i+Uint64FromInt32(v47) <= Uint64FromInt32(p)) { + if !(v45 && i+Uint64FromInt32(v5) <= Uint64FromInt32(p)) { break } _out(tls, f, bp+48, Uint64FromInt32(l)) goto _46 _46: ; - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) } _pad3(tls, f, uint8(' '), w, p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) if w > p { - v50 = w + v5 = w } else { - v50 = p + v5 = p } - l = v50 + l = v5 goto _1 _29: ; @@ -141666,7 +141666,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _51 _51: ; - i++ + i = i + 1 } for { if !(i <= uint64(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -141675,7 +141675,7 @@ func _printf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _52 _52: ; - i++ + i = i + 1 } if i <= uint64(NL_ARGMAX) { goto inval @@ -141701,12 +141701,12 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { bp := tls.Alloc(208) defer tls.Free(208) var __need_unlock, olderr, ret, v1 int32 - var saved_buf, v2, v3, v4, v5 uintptr + var saved_buf, v2, v3 uintptr var _ /* ap2 at bp+0 */ Tva_list var _ /* internal_buf at bp+128 */ [80]uint8 var _ /* nl_arg at bp+48 */ [10]Targ var _ /* nl_type at bp+8 */ [10]int32 - _, _, _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = __need_unlock, olderr, ret, saved_buf, v1, v2, v3 *(*[10]int32)(unsafe.Pointer(bp + 8)) = [10]int32{} saved_buf = uintptr(0) /* the copy allows passing va_list* even if va_list is an array */ @@ -141745,11 +141745,11 @@ func Xvfprintf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } (*TFILE)(unsafe.Pointer(f)).Fbuf = saved_buf (*TFILE)(unsafe.Pointer(f)).Fbuf_size = uint64(0) - v5 = UintptrFromInt32(0) - (*TFILE)(unsafe.Pointer(f)).Fwend = v5 - v4 = v5 - (*TFILE)(unsafe.Pointer(f)).Fwbase = v4 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v4 + v3 = UintptrFromInt32(0) + (*TFILE)(unsafe.Pointer(f)).Fwend = v3 + v2 = v3 + (*TFILE)(unsafe.Pointer(f)).Fwbase = v2 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v2 } if (*TFILE)(unsafe.Pointer(f)).Fflags&uint32(F_ERR) != 0 { ret = -int32(1) @@ -141803,7 +141803,7 @@ func _arg_n(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -141817,17 +141817,17 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(288) defer tls.Free(288) - var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v12, v13, v16, v17, v20, v21, v23, v29, v3, v32, v33, v36, v4, v6, v64, v65, v69, v7, v70, v75, v76, v80, v81, v9 int32 - var dest, p, s, tmp, tmp1, wcs, v10, v11, v18, v19, v24, v25, v28, v30, v31, v37, v38, v59, v62, v66, v67, v71, v72, v74, v77, v78, v82, v83 uintptr - var i, k, v68, v73, v79 Tsize_t + var __need_unlock, alloc, base, c, invert, matches, size, t, width, v1, v3, v4, v6 int32 + var dest, p, s, tmp, tmp1, wcs, v10, v11, v17 uintptr + var i, k, v64 Tsize_t var pos Toff_t var x uint64 var y float64 - var v63 uint32 + var v59 uint32 var _ /* scanset at bp+16 */ [257]uint8 var _ /* st at bp+8 */ Tmbstate_t var _ /* wc at bp+276 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v12, v13, v16, v17, v18, v19, v20, v21, v23, v24, v25, v28, v29, v3, v30, v31, v32, v33, v36, v37, v38, v4, v59, v6, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, base, c, dest, i, invert, k, matches, p, pos, s, size, t, tmp, tmp1, wcs, width, x, y, v1, v10, v11, v17, v3, v4, v59, v6, v64 alloc = 0 dest = UintptrFromInt32(0) matches = 0 @@ -141850,99 +141850,99 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } alloc = 0 - v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) + v3 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _5 _5: - if v4 != 0 { + if v3 != 0 { for { - v6 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) - v7 = BoolInt32(v6 == int32(' ') || Uint32FromInt32(v6)-uint32('\t') < uint32(5)) + v4 = Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) goto _8 _8: - if !(v7 != 0) { + if !(v6 != 0) { break } - p++ + p = p + 1 } X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { v11 = f + 8 v10 = *(*uintptr)(unsafe.Pointer(v11)) - *(*uintptr)(unsafe.Pointer(v11))++ - v9 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v9 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v12 = v9 - v13 = BoolInt32(v12 == int32(' ') || Uint32FromInt32(v12)-uint32('\t') < uint32(5)) + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) goto _14 _14: - if !(v13 != 0) { + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) != int32('%') || Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('%') { X__shlim(tls, f, int64(Int32FromInt32(0))) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('%') { - p++ + p = p + 1 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v19 = f + 8 - v18 = *(*uintptr)(unsafe.Pointer(v19)) - *(*uintptr)(unsafe.Pointer(v19))++ - v17 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v18))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v17 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v16 = v17 - c = v16 - v20 = v16 - v21 = BoolInt32(v20 == int32(' ') || Uint32FromInt32(v20)-uint32('\t') < uint32(5)) - goto _22 - _22: - if !(v21 != 0) { + v1 = v3 + c = v1 + v4 = v1 + v6 = BoolInt32(v4 == int32(' ') || Uint32FromInt32(v4)-uint32('\t') < uint32(5)) + goto _21 + _21: + if !(v6 != 0) { break } } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v24))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v23 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - c = v23 + c = v1 } if c != Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) { if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if c < 0 { goto input_fail } goto match_fail } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) goto _2 } - p++ + p = p + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('*') { dest = uintptr(0) - p++ + p = p + 1 } else { if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) == int32('$') { dest = _arg_n(tls, ap, Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))-int32('0'))) - p += uintptr(2) + p = p + uintptr(2) } else { dest = VaUintptr(&ap) } @@ -141953,33 +141953,33 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) - int32('0') - goto _27 - _27: + goto _25 + _25: ; - p++ + p = p + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('m') { wcs = uintptr(0) s = uintptr(0) alloc = BoolInt32(!!(dest != 0)) - p++ + p = p + 1 } else { alloc = 0 } size = SIZE_def - v28 = p - p++ - switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v28))) { + v10 = p + p = p + 1 + switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) { case int32('h'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('h') { - p++ + p = p + 1 size = -Int32FromInt32(2) } else { size = -int32(1) } case int32('l'): if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('l') { - p++ + p = p + 1 size = Int32FromInt32(SIZE_ll) } else { size = int32(SIZE_l) @@ -142033,14 +142033,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { case int32('p'): fallthrough case int32('n'): - p-- + p = p - 1 default: goto fmt_fail } t = Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) /* C or S */ if t&int32(0x2f) == int32(3) { - t |= int32(32) + t = t | int32(32) size = int32(SIZE_l) } switch t { @@ -142058,85 +142058,85 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { X__shlim(tls, f, int64(Int32FromInt32(0))) for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v31 = f + 8 - v30 = *(*uintptr)(unsafe.Pointer(v31)) - *(*uintptr)(unsafe.Pointer(v31))++ - v29 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v30))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v29 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - v32 = v29 - v33 = BoolInt32(v32 == int32(' ') || Uint32FromInt32(v32)-uint32('\t') < uint32(5)) - goto _34 - _34: - if !(v33 != 0) { + v3 = v1 + v4 = BoolInt32(v3 == int32(' ') || Uint32FromInt32(v3)-uint32('\t') < uint32(5)) + goto _32 + _32: + if !(v4 != 0) { break } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) } X__shlim(tls, f, int64(width)) if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v38 = f + 8 - v37 = *(*uintptr)(unsafe.Pointer(v38)) - *(*uintptr)(unsafe.Pointer(v38))++ - v36 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v37))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v36 = X__shgetc(tls, f) + v1 = X__shgetc(tls, f) } - if v36 < 0 { + if v1 < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } switch t { case int32('['): - goto _40 + goto _36 case int32('c'): - goto _41 + goto _37 case int32('s'): - goto _42 + goto _38 case int32('x'): - goto _43 + goto _39 case int32('X'): - goto _44 + goto _40 case int32('p'): - goto _45 + goto _41 case int32('o'): - goto _46 + goto _42 case int32('u'): - goto _47 + goto _43 case int32('d'): - goto _48 + goto _44 case int32('i'): - goto _49 + goto _45 case int32('G'): - goto _50 + goto _46 case int32('g'): - goto _51 + goto _47 case int32('F'): - goto _52 + goto _48 case int32('f'): - goto _53 + goto _49 case int32('E'): - goto _54 + goto _50 case int32('e'): - goto _55 + goto _51 case int32('A'): - goto _56 + goto _52 case int32('a'): - goto _57 + goto _53 } - goto _58 - _42: + goto _54 + _38: ; - _41: + _37: ; - _40: + _36: ; if t == int32('c') || t == int32('s') { Xmemset(tls, bp+16, -int32(1), uint64(257)) @@ -142150,10 +142150,10 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(' ')] = uint8(0) } } else { - p++ - v59 = p - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v59))) == int32('^') { - p++ + p = p + 1 + v10 = p + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) == int32('^') { + p = p + 1 invert = Int32FromInt32(1) } else { invert = 0 @@ -142161,11 +142161,11 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xmemset(tls, bp+16, invert, uint64(257)) (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[0] = uint8(0) if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8('-')] = Uint8FromInt32(Int32FromInt32(1) - invert) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32(']') { - p++ + p = p + 1 (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[Int32FromInt32(1)+Int32FromUint8(']')] = Uint8FromInt32(Int32FromInt32(1) - invert) } } @@ -142177,36 +142177,36 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { goto fmt_fail } if Int32FromUint8(*(*uint8)(unsafe.Pointer(p))) == int32('-') && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(p + 1))) != int32(']') { - v62 = p - p++ - c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v62 + uintptr(-Int32FromInt32(1))))) + v10 = p + p = p + 1 + c = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10 + uintptr(-Int32FromInt32(1))))) for { if !(c < Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))) { break } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+c] = Uint8FromInt32(int32(1) - invert) - goto _61 - _61: + goto _57 + _57: ; - c++ + c = c + 1 } } (*(*[257]uint8)(unsafe.Pointer(bp + 16)))[int32(1)+Int32FromUint8(*(*uint8)(unsafe.Pointer(p)))] = Uint8FromInt32(int32(1) - invert) - goto _60 - _60: + goto _56 + _56: ; - p++ + p = p + 1 } } wcs = uintptr(0) s = uintptr(0) i = uint64(0) if t == int32('c') { - v63 = Uint32FromInt32(width) + uint32(1) + v59 = Uint32FromInt32(width) + uint32(1) } else { - v63 = uint32(31) + v59 = uint32(31) } - k = uint64(v63) + k = uint64(v59) if size == int32(SIZE_l) { if alloc != 0 { wcs = Xmalloc(tls, k*uint64(4)) @@ -142219,16 +142219,16 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*Tmbstate_t)(unsafe.Pointer(bp + 8)) = Tmbstate_t{} for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v67 = f + 8 - v66 = *(*uintptr)(unsafe.Pointer(v67)) - *(*uintptr)(unsafe.Pointer(v67))++ - v65 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v66))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v65 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v64 = v65 - c = v64 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v64+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } *(*uint8)(unsafe.Pointer(bp)) = Uint8FromInt32(c) @@ -142239,12 +142239,12 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { continue } if wcs != 0 { - v68 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v68)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) + v64 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v64)*4)) = *(*Twchar_t)(unsafe.Pointer(bp + 276)) } if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp != 0) { goto alloc_fail @@ -142263,23 +142263,23 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v72 = f + 8 - v71 = *(*uintptr)(unsafe.Pointer(v72)) - *(*uintptr)(unsafe.Pointer(v72))++ - v70 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v71))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v70 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v69 = v70 - c = v69 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v69+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v73 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v73))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) if i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, s, k) if !(tmp1 != 0) { goto alloc_fail @@ -142288,40 +142288,40 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } else { - v74 = dest - s = v74 - if v74 != 0 { + v10 = dest + s = v10 + if v10 != 0 { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v78 = f + 8 - v77 = *(*uintptr)(unsafe.Pointer(v78)) - *(*uintptr)(unsafe.Pointer(v78))++ - v76 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v77))) + v17 = f + 8 + v11 = *(*uintptr)(unsafe.Pointer(v17)) + *(*uintptr)(unsafe.Pointer(v17)) = *(*uintptr)(unsafe.Pointer(v17)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v11))) } else { - v76 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v75 = v76 - c = v75 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v75+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } - v79 = i - i++ - *(*uint8)(unsafe.Pointer(s + uintptr(v79))) = Uint8FromInt32(c) + v64 = i + i = i + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v64))) = Uint8FromInt32(c) } } else { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Fshend { - v83 = f + 8 - v82 = *(*uintptr)(unsafe.Pointer(v83)) - *(*uintptr)(unsafe.Pointer(v83))++ - v81 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v82))) + v11 = f + 8 + v10 = *(*uintptr)(unsafe.Pointer(v11)) + *(*uintptr)(unsafe.Pointer(v11)) = *(*uintptr)(unsafe.Pointer(v11)) + 1 + v3 = Int32FromUint8(*(*uint8)(unsafe.Pointer(v10))) } else { - v81 = X__shgetc(tls, f) + v3 = X__shgetc(tls, f) } - v80 = v81 - c = v80 - if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v80+int32(1)] != 0) { + v1 = v3 + c = v1 + if !((*(*[257]uint8)(unsafe.Pointer(bp + 16)))[v1+int32(1)] != 0) { break } } @@ -142329,7 +142329,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if (*TFILE)(unsafe.Pointer(f)).Fshlim >= 0 { - (*TFILE)(unsafe.Pointer(f)).Frpos-- + (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Frpos - 1 } if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142352,26 +142352,26 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { *(*uint8)(unsafe.Pointer(s + uintptr(i))) = uint8(0) } } - goto _58 - _45: + goto _54 + _41: ; + _40: + ; + _39: + ; + base = int32(16) + goto int_common + _42: + ; + base = int32(8) + goto int_common _44: ; _43: - ; - base = int32(16) - goto int_common - _46: - ; - base = int32(8) - goto int_common - _48: - ; - _47: ; base = int32(10) goto int_common - _49: + _45: ; base = 0 goto int_common @@ -142386,15 +142386,7 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { _store_int(tls, dest, size, x) } - goto _58 - _57: - ; - _56: - ; - _55: - ; - _54: - ; + goto _54 _53: ; _52: @@ -142403,6 +142395,14 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { ; _50: ; + _49: + ; + _48: + ; + _47: + ; + _46: + ; y = X__floatscan(tls, f, size, 0) if !((*TFILE)(unsafe.Pointer(f)).Fshcnt+(int64((*TFILE)(unsafe.Pointer(f)).Frpos)-int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) != 0) { goto match_fail @@ -142418,20 +142418,20 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } } - goto _58 - _58: + goto _54 + _54: ; - pos += (*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf)) + pos = pos + ((*TFILE)(unsafe.Pointer(f)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(f)).Frpos) - int64((*TFILE)(unsafe.Pointer(f)).Fbuf))) if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: ; - p++ + p = p + 1 } if !(0 != 0) { - goto _85 + goto _80 } goto fmt_fail fmt_fail: @@ -142443,7 +142443,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -142452,7 +142452,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_85: +_80: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -142624,7 +142624,7 @@ func _out1(tls *TLS, f uintptr, s uintptr, l Tsize_t) { _, _ = v1, v2 for { v1 = l - l-- + l = l - 1 if !(v1 != 0 && !((*TFILE)(unsafe.Pointer(f)).Fflags&Uint32FromInt32(F_ERR) != 0)) { break } @@ -142681,7 +142681,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, bp := tls.Alloc(112) defer tls.Free(112) var a, bs, z, v8 uintptr - var argpos, cnt, i, l, p, t, w, xp, v10, v12, v13, v14, v16, v5, v6, v7 int32 + var argpos, cnt, i, l, p, t, w, xp, v5, v6, v7 int32 var fl, l10n, ps, st uint32 var v15 bool var v9 uint64 @@ -142689,7 +142689,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, var _ /* charfmt at bp+24 */ [16]uint8 var _ /* s at bp+8 */ uintptr var _ /* wc at bp+40 */ Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v10, v12, v13, v14, v15, v16, v5, v6, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argpos, bs, cnt, fl, i, l, l10n, p, ps, st, t, w, xp, z, v15, v5, v6, v7, v8, v9 *(*uintptr)(unsafe.Pointer(bp + 8)) = fmt l10n = uint32(0) cnt = 0 @@ -142702,7 +142702,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto overflow } /* Update output count, end loop when fmt is exhausted */ - cnt += l + cnt = cnt + l if !(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) != 0) { break } @@ -142726,7 +142726,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _3: ; z += 4 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } if (int64(z)-int64(a))/4 > int64(int32(INT_MAX)-cnt) { goto overflow @@ -142741,7 +142741,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)) == int32('$') { l10n = uint32(1) argpos = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4)) - int32('0') - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { argpos = -int32(1) *(*uintptr)(unsafe.Pointer(bp + 8)) += 4 @@ -142752,7 +142752,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if !(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))))-uint32(' ') < uint32(32) && (Uint32FromUint32(1)<<(Int32FromUint8('#')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('0')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8(' ')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('+')-Int32FromUint8(' '))|Uint32FromUint32(1)<<(Int32FromUint8('\'')-Int32FromUint8(' ')))&(uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' '))) != 0) { break } - fl |= uint32(1) << (*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)))) - int32(' ')) + fl = fl | uint32(1)<<(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8))))-int32(' ')) goto _4 _4: ; @@ -142764,7 +142764,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, l10n = uint32(1) *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*4)) = int32(_INT) w = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 1*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(3) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(3)*4 } else { if !(l10n != 0) { if f != 0 { @@ -142779,13 +142779,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } } if w < 0 { - fl |= Uint32FromUint32(1) << (Int32FromUint8('-') - Int32FromUint8(' ')) + fl = fl | Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')) w = -w } } else { - v6 = _getint1(tls, bp+8) - w = v6 - if v6 < 0 { + v5 = _getint1(tls, bp+8) + w = v5 + if v5 < 0 { goto overflow } } @@ -142794,16 +142794,16 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 3*4)) == int32('$') { *(*int32)(unsafe.Pointer(nl_type + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*4)) = int32(_INT) p = Int32FromUint64(*(*Tuintmax_t)(unsafe.Pointer(nl_arg + uintptr(*(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + 2*4))-int32('0'))*8))) - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(4) * 4 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(4)*4 } else { if !(l10n != 0) { if f != 0 { - v7 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) + v5 = VaInt32(&*(*Tva_list)(unsafe.Pointer(ap))) } else { - v7 = 0 + v5 = 0 } - p = v7 - *(*uintptr)(unsafe.Pointer(bp + 8)) += uintptr(2) * 4 + p = v5 + *(*uintptr)(unsafe.Pointer(bp + 8)) = *(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(2)*4 } else { goto inval } @@ -142859,7 +142859,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, } t = *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 8)) + uintptr(-Int32FromInt32(1))*4)) if ps != 0 && t&int32(15) == int32(3) { - t &= ^Int32FromInt32(32) + t = t & ^Int32FromInt32(32) } switch t { case int32('n'): @@ -142901,11 +142901,11 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, case int32('S'): a = *(*uintptr)(unsafe.Pointer(bp + 16)) if p < 0 { - v10 = int32(INT_MAX) + v5 = int32(INT_MAX) } else { - v10 = p + v5 = p } - z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v10)))*4 + z = a + uintptr(Xwcsnlen(tls, a, Uint64FromInt32(v5)))*4 if p < 0 && *(*Twchar_t)(unsafe.Pointer(z)) != 0 { goto overflow } @@ -142926,27 +142926,27 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, *(*uintptr)(unsafe.Pointer(bp + 16)) = __ccgo_ts + 1657 } bs = *(*uintptr)(unsafe.Pointer(bp + 16)) - v12 = Int32FromInt32(0) - l = v12 - i = v12 + v5 = Int32FromInt32(0) + l = v5 + i = v5 for { if p < 0 { - v13 = int32(INT_MAX) + v6 = int32(INT_MAX) } else { - v13 = p + v6 = p } - if v15 = l < v13; v15 { - v14 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - i = v14 + if v15 = l < v6; v15 { + v7 = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) + i = v7 } - if !(v15 && v14 > 0) { + if !(v15 && v7 > 0) { break } goto _11 _11: ; - bs += uintptr(i) - l++ + bs = bs + uintptr(i) + l = l + 1 } if i < 0 { return -int32(1) @@ -142961,13 +142961,13 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, _pad4(tls, f, w-p, Int32FromUint32(fl)) bs = *(*uintptr)(unsafe.Pointer(bp + 16)) for { - v16 = l - l-- - if !(v16 != 0) { + v5 = l + l = l - 1 + if !(v5 != 0) { break } i = Xmbtowc(tls, bp+40, bs, uint64(MB_LEN_MAX)) - bs += uintptr(i) + bs = bs + uintptr(i) _out1(tls, f, bp+40, uint64(1)) } _pad4(tls, f, w-p, Int32FromUint32(fl^Uint32FromUint32(1)<<(Int32FromUint8('-')-Int32FromUint8(' ')))) @@ -143019,7 +143019,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _17 _17: ; - i++ + i = i + 1 } for { if !(i <= int32(NL_ARGMAX) && !(*(*int32)(unsafe.Pointer(nl_type + uintptr(i)*4)) != 0)) { @@ -143028,7 +143028,7 @@ func _wprintf_core(tls *TLS, f uintptr, fmt uintptr, ap uintptr, nl_arg uintptr, goto _18 _18: ; - i++ + i = i + 1 } if i <= int32(NL_ARGMAX) { return -int32(1) @@ -143120,7 +143120,7 @@ func _arg_n1(tls *TLS, ap Tva_list, n uint32) (r uintptr) { goto _1 _1: ; - i-- + i = i - 1 } p = VaUintptr(&ap2) _ = ap2 @@ -143163,7 +143163,7 @@ func _in_set(tls *TLS, set uintptr, c int32) (r int32) { goto _2 _2: ; - j++ + j = j + 1 } } if c == *(*Twchar_t)(unsafe.Pointer(p)) { @@ -143184,14 +143184,14 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } bp := tls.Alloc(80) defer tls.Free(80) - var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1, v10, v22, v3, v36 int32 - var dest, p, s, set, tmp1, tmp2, wcs, v12, v13, v15, v16, v18, v19, v21, v24, v25, v27, v28, v30, v31, v32, v33, v34, v38, v39, v41, v43, v44, v45, v5, v6, v8, v9 uintptr - var i, k, v40 Tsize_t + var __need_unlock, alloc, c, gotmatch, invert, l, matches, size, t, width, v1 int32 + var dest, p, s, set, tmp1, tmp2, wcs, v5, v6 uintptr + var i, k, v37 Tsize_t var pos Toff_t - var v11, v14, v23, v26, v35, v37, v4 uint32 + var v4 uint32 var _ /* cnt at bp+0 */ Toff_t var _ /* tmp at bp+8 */ [22]uint8 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v10, v11, v12, v13, v14, v15, v16, v18, v19, v21, v22, v23, v24, v25, v26, v27, v28, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v4, v40, v41, v43, v44, v45, v5, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = __need_unlock, alloc, c, dest, gotmatch, i, invert, k, l, matches, p, pos, s, set, size, t, tmp1, tmp2, wcs, width, v1, v37, v4, v5, v6 dest = UintptrFromInt32(0) matches = 0 pos = 0 @@ -143216,23 +143216,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { v6 = f + 8 v5 = *(*uintptr)(unsafe.Pointer(v6)) - *(*uintptr)(unsafe.Pointer(v6))++ + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { v4 = Xgetwc(tls, f) } - v3 = Int32FromUint32(v4) - c = v3 - if !(Xiswspace(tls, Uint32FromInt32(v3)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v9 = f + 8 - *(*uintptr)(unsafe.Pointer(v9))-- - v8 = *(*uintptr)(unsafe.Pointer(v9)) - _ = *(*uint8)(unsafe.Pointer(v8)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143243,37 +143243,37 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v13 = f + 8 - v12 = *(*uintptr)(unsafe.Pointer(v13)) - *(*uintptr)(unsafe.Pointer(v13))++ - v11 = uint32(*(*uint8)(unsafe.Pointer(v12))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v11 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v10 = Int32FromUint32(v11) - c = v10 - if !(Xiswspace(tls, Uint32FromInt32(v10)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v16 = f + 8 - v15 = *(*uintptr)(unsafe.Pointer(v16)) - *(*uintptr)(unsafe.Pointer(v16))++ - v14 = uint32(*(*uint8)(unsafe.Pointer(v15))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v14 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v14) + c = Int32FromUint32(v4) } if c != *(*Twchar_t)(unsafe.Pointer(p)) { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v19 = f + 8 - *(*uintptr)(unsafe.Pointer(v19))-- - v18 = *(*uintptr)(unsafe.Pointer(v19)) - _ = *(*uint8)(unsafe.Pointer(v18)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143282,7 +143282,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } goto match_fail } - pos++ + pos = pos + 1 goto _2 } p += 4 @@ -143292,7 +143292,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if BoolInt32(Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p)))-uint32('0') < uint32(10)) != 0 && *(*Twchar_t)(unsafe.Pointer(p + 1*4)) == int32('$') { dest = _arg_n1(tls, ap, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(p))-int32('0'))) - p += uintptr(2) * 4 + p = p + uintptr(2)*4 } else { dest = VaUintptr(&ap) } @@ -143303,8 +143303,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { break } width = int32(10)*width + *(*Twchar_t)(unsafe.Pointer(p)) - int32('0') - goto _20 - _20: + goto _18 + _18: ; p += 4 } @@ -143317,9 +143317,9 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { alloc = 0 } size = SIZE_def - v21 = p + v5 = p p += 4 - switch *(*Twchar_t)(unsafe.Pointer(v21)) { + switch *(*Twchar_t)(unsafe.Pointer(v5)) { case int32('h'): if *(*Twchar_t)(unsafe.Pointer(p)) == int32('h') { p += 4 @@ -143391,45 +143391,45 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { /* Transform S,C -> ls,lc */ if t&int32(0x2f) == int32(3) { size = int32(SIZE_l) - t |= int32(32) + t = t | int32(32) } if t != int32('n') { if t != int32('[') && t|int32(32) != int32('c') { for { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v25 = f + 8 - v24 = *(*uintptr)(unsafe.Pointer(v25)) - *(*uintptr)(unsafe.Pointer(v25))++ - v23 = uint32(*(*uint8)(unsafe.Pointer(v24))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v23 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v22 = Int32FromUint32(v23) - c = v22 - if !(Xiswspace(tls, Uint32FromInt32(v22)) != 0) { + v1 = Int32FromUint32(v4) + c = v1 + if !(Xiswspace(tls, Uint32FromInt32(v1)) != 0) { break } - pos++ + pos = pos + 1 } } else { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v28 = f + 8 - v27 = *(*uintptr)(unsafe.Pointer(v28)) - *(*uintptr)(unsafe.Pointer(v28))++ - v26 = uint32(*(*uint8)(unsafe.Pointer(v27))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v26 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - c = Int32FromUint32(v26) + c = Int32FromUint32(v4) } if c < 0 { goto input_fail } if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v31 = f + 8 - *(*uintptr)(unsafe.Pointer(v31))-- - v30 = *(*uintptr)(unsafe.Pointer(v31)) - _ = *(*uint8)(unsafe.Pointer(v30)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143456,8 +143456,8 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { set = uintptr(unsafe.Pointer(&_spaces1)) } else { p += 4 - v32 = p - if *(*Twchar_t)(unsafe.Pointer(v32)) == int32('^') { + v5 = p + if *(*Twchar_t)(unsafe.Pointer(v5)) == int32('^') { p += 4 invert = Int32FromInt32(1) } else { @@ -143476,17 +143476,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } if size == SIZE_def { - v33 = dest + v5 = dest } else { - v33 = uintptr(0) + v5 = uintptr(0) } - s = v33 + s = v5 if size == int32(SIZE_l) { - v34 = dest + v5 = dest } else { - v34 = uintptr(0) + v5 = uintptr(0) } - wcs = v34 + wcs = v5 gotmatch = 0 if width < int32(1) { width = -int32(1) @@ -143494,11 +143494,11 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { i = uint64(0) if alloc != 0 { if t == int32('c') { - v35 = Uint32FromInt32(width) + uint32(1) + v4 = Uint32FromInt32(width) + uint32(1) } else { - v35 = uint32(31) + v4 = uint32(31) } - k = uint64(v35) + k = uint64(v4) if size == int32(SIZE_l) { wcs = Xmalloc(tls, k*uint64(4)) if !(wcs != 0) { @@ -143513,27 +143513,27 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } for width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frpos != (*TFILE)(unsafe.Pointer(f)).Frend && Int32FromUint8(*(*uint8)(unsafe.Pointer((*TFILE)(unsafe.Pointer(f)).Frpos))) < int32(128) { - v39 = f + 8 - v38 = *(*uintptr)(unsafe.Pointer(v39)) - *(*uintptr)(unsafe.Pointer(v39))++ - v37 = uint32(*(*uint8)(unsafe.Pointer(v38))) + v6 = f + 8 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) + 1 + v4 = uint32(*(*uint8)(unsafe.Pointer(v5))) } else { - v37 = Xgetwc(tls, f) + v4 = Xgetwc(tls, f) } - v36 = Int32FromUint32(v37) - c = v36 - if v36 < 0 { + v1 = Int32FromUint32(v4) + c = v1 + if v1 < 0 { break } if _in_set(tls, set, c) == invert { break } if wcs != 0 { - v40 = i - i++ - *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v40)*4)) = c + v37 = i + i = i + 1 + *(*Twchar_t)(unsafe.Pointer(wcs + uintptr(v37)*4)) = c if alloc != 0 && i == k { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp1 = Xrealloc(tls, wcs, k*uint64(4)) if !(tmp1 != 0) { goto alloc_fail @@ -143543,17 +143543,17 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } else { if size != int32(SIZE_l) { if s != 0 { - v41 = s + uintptr(i) + v5 = s + uintptr(i) } else { - v41 = bp + 8 + v5 = bp + 8 } - l = Xwctomb(tls, v41, c) + l = Xwctomb(tls, v5, c) if l < 0 { goto input_fail } - i += Uint64FromInt32(l) + i = i + Uint64FromInt32(l) if alloc != 0 && i > k-uint64(4) { - k += k + uint64(1) + k = k + (k + uint64(1)) tmp2 = Xrealloc(tls, s, k) if !(tmp2 != 0) { goto alloc_fail @@ -143562,16 +143562,16 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { } } } - pos++ - width -= BoolInt32(width > 0) + pos = pos + 1 + width = width - BoolInt32(width > 0) gotmatch = int32(1) } if width != 0 { if (*TFILE)(unsafe.Pointer(f)).Frend != 0 && Uint32FromInt32(c) < uint32(128) { - v44 = f + 8 - *(*uintptr)(unsafe.Pointer(v44))-- - v43 = *(*uintptr)(unsafe.Pointer(v44)) - _ = *(*uint8)(unsafe.Pointer(v43)) + v6 = f + 8 + *(*uintptr)(unsafe.Pointer(v6)) = *(*uintptr)(unsafe.Pointer(v6)) - 1 + v5 = *(*uintptr)(unsafe.Pointer(v6)) + _ = *(*uint8)(unsafe.Pointer(v5)) } else { Xungetwc(tls, Uint32FromInt32(c), f) } @@ -143629,23 +143629,23 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { Xsnprintf(tls, bp+8, uint64(22), __ccgo_ts+1700, VaList(bp+40, int32(1)+BoolInt32(!(dest != 0)), __ccgo_ts+1718, width, uintptr(unsafe.Pointer(&_size_pfx))+uintptr(size+int32(2))*3, t)) *(*Toff_t)(unsafe.Pointer(bp)) = 0 if dest != 0 { - v45 = dest + v5 = dest } else { - v45 = bp + v5 = bp } - if Xfscanf(tls, f, bp+8, VaList(bp+40, v45, bp)) == -int32(1) { + if Xfscanf(tls, f, bp+8, VaList(bp+40, v5, bp)) == -int32(1) { goto input_fail } else { if !(*(*Toff_t)(unsafe.Pointer(bp)) != 0) { goto match_fail } } - pos += *(*Toff_t)(unsafe.Pointer(bp)) + pos = pos + *(*Toff_t)(unsafe.Pointer(bp)) default: goto fmt_fail } if dest != 0 { - matches++ + matches = matches + 1 } goto _2 _2: @@ -143653,7 +143653,7 @@ func Xvfwscanf(tls *TLS, f uintptr, fmt uintptr, ap Tva_list) (r int32) { p += 4 } if !(0 != 0) { - goto _46 + goto _42 } goto fmt_fail fmt_fail: @@ -143665,7 +143665,7 @@ alloc_fail: input_fail: ; if !(matches != 0) { - matches-- + matches = matches - 1 } goto match_fail match_fail: @@ -143674,7 +143674,7 @@ match_fail: Xfree(tls, s) Xfree(tls, wcs) } -_46: +_42: ; if __need_unlock != 0 { ___unlockfile(tls, f) @@ -143755,8 +143755,8 @@ type Tcookie3 = struct { func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { var c, v3 uintptr var k Tsize_t - var v1, v2 uint64 - _, _, _, _, _ = c, k, v1, v2, v3 + var v1 uint64 + _, _, _, _ = c, k, v1, v3 c = (*TFILE)(unsafe.Pointer(f)).Fcookie if (*Tcookie3)(unsafe.Pointer(c)).Fn < Uint64FromInt64(int64((*TFILE)(unsafe.Pointer(f)).Fwpos)-int64((*TFILE)(unsafe.Pointer(f)).Fwbase)) { v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn @@ -143770,11 +143770,11 @@ func _sn_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { *(*Tsize_t)(unsafe.Pointer(c + 8)) -= k } if (*Tcookie3)(unsafe.Pointer(c)).Fn < l { - v2 = (*Tcookie3)(unsafe.Pointer(c)).Fn + v1 = (*Tcookie3)(unsafe.Pointer(c)).Fn } else { - v2 = l + v1 = l } - k = v2 + k = v1 if k != 0 { Xmemcpy(tls, (*Tcookie3)(unsafe.Pointer(c)).Fs, s, k) *(*uintptr)(unsafe.Pointer(c)) += uintptr(k) @@ -143895,11 +143895,11 @@ type Tcookie4 = struct { } func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { - var c, v3, v4, v5 uintptr + var c, v3, v4 uintptr var i, v1 int32 var l0 Tsize_t var v2 bool - _, _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4, v5 + _, _, _, _, _, _, _ = c, i, l0, v1, v2, v3, v4 l0 = l i = 0 c = (*TFILE)(unsafe.Pointer(f)).Fcookie @@ -143917,9 +143917,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { if !(i != 0) { i = int32(1) } - s += uintptr(i) - l -= Uint64FromInt32(i) - (*Tcookie4)(unsafe.Pointer(c)).Fl-- + s = s + uintptr(i) + l = l - Uint64FromInt32(i) + (*Tcookie4)(unsafe.Pointer(c)).Fl = (*Tcookie4)(unsafe.Pointer(c)).Fl - 1 (*Tcookie4)(unsafe.Pointer(c)).Fws += 4 } *(*Twchar_t)(unsafe.Pointer((*Tcookie4)(unsafe.Pointer(c)).Fws)) = 0 @@ -143933,9 +143933,9 @@ func _sw_write(tls *TLS, f uintptr, s uintptr, l Tsize_t) (r Tsize_t) { return Uint64FromInt32(i) } (*TFILE)(unsafe.Pointer(f)).Fwend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr((*TFILE)(unsafe.Pointer(f)).Fbuf_size) - v5 = (*TFILE)(unsafe.Pointer(f)).Fbuf - (*TFILE)(unsafe.Pointer(f)).Fwbase = v5 - (*TFILE)(unsafe.Pointer(f)).Fwpos = v5 + v3 = (*TFILE)(unsafe.Pointer(f)).Fbuf + (*TFILE)(unsafe.Pointer(f)).Fwbase = v3 + (*TFILE)(unsafe.Pointer(f)).Fwpos = v3 return l0 } @@ -143980,9 +143980,9 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { bp := tls.Alloc(16) defer tls.Free(16) var k Tsize_t - var v1, v2, v3 uintptr + var v1, v2 uintptr var _ /* src at bp+0 */ uintptr - _, _, _, _ = k, v1, v2, v3 + _, _, _ = k, v1, v2 *(*uintptr)(unsafe.Pointer(bp)) = (*TFILE)(unsafe.Pointer(f)).Fcookie if !(*(*uintptr)(unsafe.Pointer(bp)) != 0) { return uint64(0) @@ -144000,10 +144000,10 @@ func _wstring_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if !(len1 != 0) || !(k != 0) { return uint64(0) } - v3 = f + 8 - v2 = *(*uintptr)(unsafe.Pointer(v3)) - *(*uintptr)(unsafe.Pointer(v3))++ - *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v2)) + v2 = f + 8 + v1 = *(*uintptr)(unsafe.Pointer(v2)) + *(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1 + *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v1)) return uint64(1) } @@ -144122,9 +144122,9 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { trc("tls=%v s=%v, (%v:)", tls, s, origin(2)) defer func() { trc("-> %v", r) }() } - var n, neg, v1, v2, v5 int32 + var n, neg, v1, v2 int32 var v4 uintptr - _, _, _, _, _, _ = n, neg, v1, v2, v4, v5 + _, _, _, _, _ = n, neg, v1, v2, v4 n = 0 neg = 0 for { @@ -144135,27 +144135,27 @@ func Xatoi(tls *TLS, s uintptr) (r int32) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on INT_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int32(10)*n - (Int32FromUint8(*(*uint8)(unsafe.Pointer(v4))) - int32('0')) } if neg != 0 { - v5 = n + v1 = n } else { - v5 = -n + v1 = -n } - return v5 + return v1 } func Xatol(tls *TLS, s uintptr) (r int64) { @@ -144177,19 +144177,19 @@ func Xatol(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144219,19 +144219,19 @@ func Xatoll(tls *TLS, s uintptr) (r int64) { if !(v2 != 0) { break } - s++ + s = s + 1 } switch Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) { case int32('-'): neg = int32(1) fallthrough case int32('+'): - s++ + s = s + 1 } /* Compute n as a negative number to avoid overflow on LLONG_MIN */ for BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0 { v4 = s - s++ + s = s + 1 n = int64(10)*n - int64(Int32FromUint8(*(*uint8)(unsafe.Pointer(v4)))-Int32FromUint8('0')) } if neg != 0 { @@ -144256,11 +144256,11 @@ func Xbsearch(tls *TLS, key uintptr, base uintptr, nel Tsize_t, width Tsize_t, _ try = base + uintptr(width*(nel/uint64(2))) sign = (*(*func(*TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, key, try) if sign < 0 { - nel /= uint64(2) + nel = nel / uint64(2) } else { if sign > 0 { base = try + uintptr(width) - nel -= nel/uint64(2) + uint64(1) + nel = nel - (nel/uint64(2) + uint64(1)) } else { return try } @@ -144287,9 +144287,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { } bp := tls.Alloc(64) defer tls.Free(64) - var i, j, v1, v3 int32 + var i, j, v1 int32 var _ /* tmp at bp+0 */ [32]uint8 - _, _, _, _ = i, j, v1, v3 + _, _, _ = i, j, v1 if Uint32FromInt32(n)-uint32(1) > uint32(15) { n = int32(15) } @@ -144306,9 +144306,9 @@ func Xecvt(tls *TLS, x float64, n int32, dp uintptr, sign uintptr) (r uintptr) { goto _2 _2: ; - v3 = i - i++ - j += BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v3]) != int32('.')) + v1 = i + i = i + 1 + j = j + BoolInt32(Int32FromUint8((*(*[32]uint8)(unsafe.Pointer(bp)))[v1]) != int32('.')) } _buf8[j] = uint8(0) *(*int32)(unsafe.Pointer(dp)) = Xatoi(tls, bp+uintptr(i)+uintptr(1)) + int32(1) @@ -144493,9 +144493,9 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { goto _2 _2: ; - i++ + i = i + 1 } - width -= l + width = width - l } } @@ -144504,7 +144504,7 @@ func _cycle(tls *TLS, width Tsize_t, ar uintptr, n int32) { // /* shl() and shr() need n > 0 */ func _shl(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = *(*Tsize_t)(unsafe.Pointer(p)) *(*Tsize_t)(unsafe.Pointer(p)) = uint64(0) } @@ -144515,7 +144515,7 @@ func _shl(tls *TLS, p uintptr, n int32) { func _shr(tls *TLS, p uintptr, n int32) { if Uint64FromInt32(n) >= Uint64FromInt32(8)*Uint64FromInt64(8) { - n = int32(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) + n = Int32FromUint64(uint64(n) - Uint64FromInt32(8)*Uint64FromInt64(8)) *(*Tsize_t)(unsafe.Pointer(p)) = *(*Tsize_t)(unsafe.Pointer(p + 1*8)) *(*Tsize_t)(unsafe.Pointer(p + 1*8)) = uint64(0) } @@ -144527,10 +144527,10 @@ func _shr(tls *TLS, p uintptr, n int32) { func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uintptr, pshift int32, lp uintptr) { bp := tls.Alloc(912) defer tls.Free(912) - var i, v1, v2 int32 + var i, v1 int32 var lf, rt uintptr var _ /* ar at bp+0 */ [113]uintptr - _, _, _, _, _ = i, lf, rt, v1, v2 + _, _, _, _ = i, lf, rt, v1 i = int32(1) (*(*[113]uintptr)(unsafe.Pointer(bp)))[0] = head for pshift > int32(1) { @@ -144541,16 +144541,16 @@ func _sift(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg uin } if (*(*func(*TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_cmp})))(tls, lf, rt, arg) >= 0 { v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = lf head = lf - pshift -= int32(1) + pshift = pshift - int32(1) } else { - v2 = i - i++ - (*(*[113]uintptr)(unsafe.Pointer(bp)))[v2] = rt + v1 = i + i = i + 1 + (*(*[113]uintptr)(unsafe.Pointer(bp)))[v1] = rt head = rt - pshift -= int32(2) + pshift = pshift - int32(2) } } _cycle(tls, width, bp, i) @@ -144581,12 +144581,12 @@ func _trinkle(tls *TLS, head uintptr, width Tsize_t, __ccgo_fp_cmp Tcmpfun, arg } } v1 = i - i++ + i = i + 1 (*(*[113]uintptr)(unsafe.Pointer(bp + 16)))[v1] = stepson head = stepson trail = _pntz(tls, bp) _shr(tls, bp, trail) - pshift += trail + pshift = pshift + trail trusty = 0 } if !(trusty != 0) { @@ -144633,13 +144633,13 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm goto _1 _1: ; - i++ + i = i + 1 } for head < high { if (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0]&uint64(3) == uint64(3) { _sift(tls, head, width, __ccgo_fp_cmp, arg, pshift, bp) _shr(tls, bp+768, int32(2)) - pshift += int32(2) + pshift = pshift + int32(2) } else { if (*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift-int32(1)] >= Uint64FromInt64(int64(high)-int64(head)) { _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) @@ -144655,17 +144655,17 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm } } *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) - head += uintptr(width) + head = head + uintptr(width) } _trinkle(tls, head, width, __ccgo_fp_cmp, arg, bp+768, pshift, 0, bp) for pshift != int32(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[0] != uint64(1) || (*(*[2]Tsize_t)(unsafe.Pointer(bp + 768)))[int32(1)] != uint64(0) { if pshift <= int32(1) { trail = _pntz(tls, bp+768) _shr(tls, bp+768, trail) - pshift += trail + pshift = pshift + trail } else { _shl(tls, bp+768, int32(2)) - pshift -= int32(2) + pshift = pshift - int32(2) *(*Tsize_t)(unsafe.Pointer(bp + 768)) ^= uint64(7) _shr(tls, bp+768, int32(1)) _trinkle(tls, head-uintptr((*(*[96]Tsize_t)(unsafe.Pointer(bp)))[pshift])-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift+int32(1), int32(1), bp) @@ -144673,7 +144673,7 @@ func X__qsort_r(tls *TLS, base uintptr, nel Tsize_t, width Tsize_t, __ccgo_fp_cm *(*Tsize_t)(unsafe.Pointer(bp + 768)) |= uint64(1) _trinkle(tls, head-uintptr(width), width, __ccgo_fp_cmp, arg, bp+768, pshift, int32(1), bp) } - head -= uintptr(width) + head = head - uintptr(width) } } @@ -144704,9 +144704,9 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { defer tls.Free(240) var cnt Toff_t var y float64 - var v1, v2 uintptr + var v1 uintptr var _ /* f at bp+0 */ TFILE - _, _, _, _ = cnt, y, v1, v2 + _, _, _ = cnt, y, v1 v1 = s (*TFILE)(unsafe.Pointer(bp)).Frpos = v1 (*TFILE)(unsafe.Pointer(bp)).Fbuf = v1 @@ -144716,11 +144716,11 @@ func _strtox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { cnt = (*TFILE)(unsafe.Pointer(bp)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp)).Fbuf)) if p != 0 { if cnt != 0 { - v2 = s + uintptr(cnt) + v1 = s + uintptr(cnt) } else { - v2 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v2 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144893,7 +144893,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -144901,7 +144901,7 @@ func _do_read(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -144912,11 +144912,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y float64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -144937,11 +144937,11 @@ func _wcstox(tls *TLS, s uintptr, p uintptr, prec int32) (r float64) { if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -144997,7 +144997,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { goto _1 _1: ; - i++ + i = i + 1 } (*TFILE)(unsafe.Pointer(f)).Frpos = (*TFILE)(unsafe.Pointer(f)).Fbuf (*TFILE)(unsafe.Pointer(f)).Frend = (*TFILE)(unsafe.Pointer(f)).Fbuf + uintptr(i) @@ -145005,7 +145005,7 @@ func _do_read1(tls *TLS, f uintptr, buf uintptr, len1 Tsize_t) (r Tsize_t) { if i != 0 && len1 != 0 { v4 = f + 8 v3 = *(*uintptr)(unsafe.Pointer(v4)) - *(*uintptr)(unsafe.Pointer(v4))++ + *(*uintptr)(unsafe.Pointer(v4)) = *(*uintptr)(unsafe.Pointer(v4)) + 1 *(*uint8)(unsafe.Pointer(buf)) = *(*uint8)(unsafe.Pointer(v3)) return uint64(1) } @@ -145016,11 +145016,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) bp := tls.Alloc(304) defer tls.Free(304) var cnt Tsize_t - var t, v1, v2, v3 uintptr + var t, v1, v2 uintptr var y uint64 var _ /* buf at bp+0 */ [64]uint8 var _ /* f at bp+64 */ TFILE - _, _, _, _, _, _ = cnt, t, y, v1, v2, v3 + _, _, _, _, _ = cnt, t, y, v1, v2 t = s *(*TFILE)(unsafe.Pointer(bp + 64)) = TFILE{} (*(*TFILE)(unsafe.Pointer(bp + 64))).Fflags = uint32(0) @@ -145041,11 +145041,11 @@ func _wcstox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) (r uint64) if p != 0 { cnt = Uint64FromInt64((*TFILE)(unsafe.Pointer(bp+64)).Fshcnt + (int64((*TFILE)(unsafe.Pointer(bp+64)).Frpos) - int64((*TFILE)(unsafe.Pointer(bp+64)).Fbuf))) if cnt != 0 { - v3 = t + uintptr(cnt)*4 + v1 = t + uintptr(cnt)*4 } else { - v3 = s + v1 = s } - *(*uintptr)(unsafe.Pointer(p)) = v3 + *(*uintptr)(unsafe.Pointer(p)) = v1 } return y } @@ -145155,9 +145155,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt } var d, s, wd, ws uintptr var k Tsize_t - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _, _, _, _ = d, k, s, wd, ws, v2, v3 d = dest s = src c = Int32FromUint8(Uint8FromInt32(c)) @@ -145173,9 +145173,9 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 { goto tail @@ -145191,7 +145191,7 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -145199,19 +145199,19 @@ func Xmemccpy(tls *TLS, dest uintptr, src uintptr, c int32, n Tsize_t) (r uintpt s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && Int32FromUint8(v6) != c) { + if !(v3 && Int32FromUint8(v2) != c) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -145250,8 +145250,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != c { k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) @@ -145264,7 +145264,7 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { _2: ; w += 8 - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) } s = w } @@ -145275,8 +145275,8 @@ func Xmemchr(tls *TLS, src uintptr, c int32, n Tsize_t) (r uintptr) { goto _3 _3: ; - s++ - n-- + s = s + 1 + n = n - 1 } if n != 0 { v4 = s @@ -145303,9 +145303,9 @@ func Xmemcmp(tls *TLS, vl uintptr, vr uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- - l++ - r++ + n = n - 1 + l = l + 1 + r = r + 1 } if n != 0 { v2 = Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) @@ -145323,9 +145323,9 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 uintptr + var d, s, v2, v3 uintptr var w, x Tuint32_t - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, s, w, x, v10, v11, v12, v13, v14, v16, v17, v18, v19, v2, v21, v22, v24, v25, v26, v27, v28, v29, v3, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v5, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v6, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v7, v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v8, v80, v81, v82, v83, v85, v86, v9 + _, _, _, _, _, _ = d, s, w, x, v2, v3 d = dest s = src for { @@ -145333,14 +145333,14 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { break } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _1 _1: ; - n-- + n = n - 1 } if uint64(d)%uint64(4) == uint64(0) { for { @@ -145354,32 +145354,32 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } if n&uint64(8) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(4))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(4))) - d += uintptr(8) - s += uintptr(8) + d = d + uintptr(8) + s = s + uintptr(8) } if n&uint64(4) != 0 { *(*uint32)(unsafe.Pointer(d + UintptrFromInt32(0))) = *(*uint32)(unsafe.Pointer(s + UintptrFromInt32(0))) - d += uintptr(4) - s += uintptr(4) + d = d + uintptr(4) + s = s + uintptr(4) } if n&uint64(2) != 0 { - v5 = d - d++ - v6 = s - s++ - *(*uint8)(unsafe.Pointer(v5)) = *(*uint8)(unsafe.Pointer(v6)) - v7 = d - d++ - v8 = s - s++ - *(*uint8)(unsafe.Pointer(v7)) = *(*uint8)(unsafe.Pointer(v8)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145390,22 +145390,22 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { switch uint64(d) % Uint64FromInt32(4) { case uint64(1): w = *(*uint32)(unsafe.Pointer(s)) - v9 = d - d++ - v10 = s - s++ - *(*uint8)(unsafe.Pointer(v9)) = *(*uint8)(unsafe.Pointer(v10)) - v11 = d - d++ - v12 = s - s++ - *(*uint8)(unsafe.Pointer(v11)) = *(*uint8)(unsafe.Pointer(v12)) - v13 = d - d++ - v14 = s - s++ - *(*uint8)(unsafe.Pointer(v13)) = *(*uint8)(unsafe.Pointer(v14)) - n -= uint64(3) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(3) for { if !(n >= uint64(17)) { break @@ -145421,23 +145421,23 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _15 _15: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(2): w = *(*uint32)(unsafe.Pointer(s)) - v16 = d - d++ - v17 = s - s++ - *(*uint8)(unsafe.Pointer(v16)) = *(*uint8)(unsafe.Pointer(v17)) - v18 = d - d++ - v19 = s - s++ - *(*uint8)(unsafe.Pointer(v18)) = *(*uint8)(unsafe.Pointer(v19)) - n -= uint64(2) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(2) for { if !(n >= uint64(18)) { break @@ -145453,18 +145453,18 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _20 _20: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } case uint64(3): w = *(*uint32)(unsafe.Pointer(s)) - v21 = d - d++ - v22 = s - s++ - *(*uint8)(unsafe.Pointer(v21)) = *(*uint8)(unsafe.Pointer(v22)) - n -= uint64(1) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + n = n - uint64(1) for { if !(n >= uint64(19)) { break @@ -145480,170 +145480,170 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _23 _23: ; - s += uintptr(16) - d += uintptr(16) - n -= uint64(16) + s = s + uintptr(16) + d = d + uintptr(16) + n = n - uint64(16) } break } } if n&uint64(16) != 0 { - v24 = d - d++ - v25 = s - s++ - *(*uint8)(unsafe.Pointer(v24)) = *(*uint8)(unsafe.Pointer(v25)) - v26 = d - d++ - v27 = s - s++ - *(*uint8)(unsafe.Pointer(v26)) = *(*uint8)(unsafe.Pointer(v27)) - v28 = d - d++ - v29 = s - s++ - *(*uint8)(unsafe.Pointer(v28)) = *(*uint8)(unsafe.Pointer(v29)) - v30 = d - d++ - v31 = s - s++ - *(*uint8)(unsafe.Pointer(v30)) = *(*uint8)(unsafe.Pointer(v31)) - v32 = d - d++ - v33 = s - s++ - *(*uint8)(unsafe.Pointer(v32)) = *(*uint8)(unsafe.Pointer(v33)) - v34 = d - d++ - v35 = s - s++ - *(*uint8)(unsafe.Pointer(v34)) = *(*uint8)(unsafe.Pointer(v35)) - v36 = d - d++ - v37 = s - s++ - *(*uint8)(unsafe.Pointer(v36)) = *(*uint8)(unsafe.Pointer(v37)) - v38 = d - d++ - v39 = s - s++ - *(*uint8)(unsafe.Pointer(v38)) = *(*uint8)(unsafe.Pointer(v39)) - v40 = d - d++ - v41 = s - s++ - *(*uint8)(unsafe.Pointer(v40)) = *(*uint8)(unsafe.Pointer(v41)) - v42 = d - d++ - v43 = s - s++ - *(*uint8)(unsafe.Pointer(v42)) = *(*uint8)(unsafe.Pointer(v43)) - v44 = d - d++ - v45 = s - s++ - *(*uint8)(unsafe.Pointer(v44)) = *(*uint8)(unsafe.Pointer(v45)) - v46 = d - d++ - v47 = s - s++ - *(*uint8)(unsafe.Pointer(v46)) = *(*uint8)(unsafe.Pointer(v47)) - v48 = d - d++ - v49 = s - s++ - *(*uint8)(unsafe.Pointer(v48)) = *(*uint8)(unsafe.Pointer(v49)) - v50 = d - d++ - v51 = s - s++ - *(*uint8)(unsafe.Pointer(v50)) = *(*uint8)(unsafe.Pointer(v51)) - v52 = d - d++ - v53 = s - s++ - *(*uint8)(unsafe.Pointer(v52)) = *(*uint8)(unsafe.Pointer(v53)) - v54 = d - d++ - v55 = s - s++ - *(*uint8)(unsafe.Pointer(v54)) = *(*uint8)(unsafe.Pointer(v55)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(8) != 0 { - v56 = d - d++ - v57 = s - s++ - *(*uint8)(unsafe.Pointer(v56)) = *(*uint8)(unsafe.Pointer(v57)) - v58 = d - d++ - v59 = s - s++ - *(*uint8)(unsafe.Pointer(v58)) = *(*uint8)(unsafe.Pointer(v59)) - v60 = d - d++ - v61 = s - s++ - *(*uint8)(unsafe.Pointer(v60)) = *(*uint8)(unsafe.Pointer(v61)) - v62 = d - d++ - v63 = s - s++ - *(*uint8)(unsafe.Pointer(v62)) = *(*uint8)(unsafe.Pointer(v63)) - v64 = d - d++ - v65 = s - s++ - *(*uint8)(unsafe.Pointer(v64)) = *(*uint8)(unsafe.Pointer(v65)) - v66 = d - d++ - v67 = s - s++ - *(*uint8)(unsafe.Pointer(v66)) = *(*uint8)(unsafe.Pointer(v67)) - v68 = d - d++ - v69 = s - s++ - *(*uint8)(unsafe.Pointer(v68)) = *(*uint8)(unsafe.Pointer(v69)) - v70 = d - d++ - v71 = s - s++ - *(*uint8)(unsafe.Pointer(v70)) = *(*uint8)(unsafe.Pointer(v71)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(4) != 0 { - v72 = d - d++ - v73 = s - s++ - *(*uint8)(unsafe.Pointer(v72)) = *(*uint8)(unsafe.Pointer(v73)) - v74 = d - d++ - v75 = s - s++ - *(*uint8)(unsafe.Pointer(v74)) = *(*uint8)(unsafe.Pointer(v75)) - v76 = d - d++ - v77 = s - s++ - *(*uint8)(unsafe.Pointer(v76)) = *(*uint8)(unsafe.Pointer(v77)) - v78 = d - d++ - v79 = s - s++ - *(*uint8)(unsafe.Pointer(v78)) = *(*uint8)(unsafe.Pointer(v79)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(2) != 0 { - v80 = d - d++ - v81 = s - s++ - *(*uint8)(unsafe.Pointer(v80)) = *(*uint8)(unsafe.Pointer(v81)) - v82 = d - d++ - v83 = s - s++ - *(*uint8)(unsafe.Pointer(v82)) = *(*uint8)(unsafe.Pointer(v83)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } if n&uint64(1) != 0 { *(*uint8)(unsafe.Pointer(d)) = *(*uint8)(unsafe.Pointer(s)) @@ -145653,27 +145653,27 @@ func Xmemcpy(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if !(n != 0) { break } - v85 = d - d++ - v86 = s - s++ - *(*uint8)(unsafe.Pointer(v85)) = *(*uint8)(unsafe.Pointer(v86)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _84 _84: ; - n-- + n = n - 1 } return dest } func _twobyte_memmem(tls *TLS, h uintptr, k Tsize_t, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145815,29 +145815,29 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -145872,22 +145872,22 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(k < l && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -145895,10 +145895,10 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _10 _10: ; - k++ + k = k + 1 } if k < l { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -145911,12 +145911,12 @@ func _twoway_memmem(tls *TLS, h uintptr, z uintptr, n uintptr, l Tsize_t) (r uin goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -145946,7 +145946,7 @@ func Xmemmem(tls *TLS, h0 uintptr, k Tsize_t, n0 uintptr, l Tsize_t) (r uintptr) if !(h != 0) || l == uint64(1) { return h } - k -= Uint64FromInt64(int64(h) - int64(h0)) + k = k - Uint64FromInt64(int64(h)-int64(h0)) if k < l { return uintptr(0) } @@ -145971,9 +145971,9 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { trc("tls=%v dest=%v src=%v n=%v, (%v:)", tls, dest, src, n, origin(2)) defer func() { trc("-> %v", r) }() } - var d, s, v2, v3, v6, v7 uintptr - var v1, v8 Tsize_t - _, _, _, _, _, _, _, _ = d, s, v1, v2, v3, v6, v7, v8 + var d, s, v2, v3 uintptr + var v1 Tsize_t + _, _, _, _, _ = d, s, v1, v2, v3 d = dest s = src if d == s { @@ -145986,14 +145986,14 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d)%Uint64FromInt64(8) != 0 { v1 = n - n-- + n = n - 1 if !(v1 != 0) { return dest } v2 = d - d++ + d = d + 1 v3 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) } for { @@ -146004,42 +146004,42 @@ func Xmemmove(tls *TLS, dest uintptr, src uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= Uint64FromInt64(8) - d += uintptr(Uint64FromInt64(8)) - s += uintptr(Uint64FromInt64(8)) + n = n - Uint64FromInt64(8) + d = d + uintptr(Uint64FromInt64(8)) + s = s + uintptr(Uint64FromInt64(8)) } } for { if !(n != 0) { break } - v6 = d - d++ - v7 = s - s++ - *(*uint8)(unsafe.Pointer(v6)) = *(*uint8)(unsafe.Pointer(v7)) + v2 = d + d = d + 1 + v3 = s + s = s + 1 + *(*uint8)(unsafe.Pointer(v2)) = *(*uint8)(unsafe.Pointer(v3)) goto _5 _5: ; - n-- + n = n - 1 } } else { if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for uint64(d+uintptr(n))%Uint64FromInt64(8) != 0 { - v8 = n - n-- - if !(v8 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { return dest } *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } for n >= Uint64FromInt64(8) { - n -= Uint64FromInt64(8) + n = n - Uint64FromInt64(8) *(*TWT)(unsafe.Pointer(d + uintptr(n))) = *(*TWT)(unsafe.Pointer(s + uintptr(n))) } } for n != 0 { - n-- + n = n - 1 *(*uint8)(unsafe.Pointer(d + uintptr(n))) = *(*uint8)(unsafe.Pointer(s + uintptr(n))) } } @@ -146066,7 +146066,7 @@ func X__memrchr(tls *TLS, m uintptr, c int32, n Tsize_t) (r uintptr) { c = Int32FromUint8(Uint8FromInt32(c)) for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -146124,9 +146124,9 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * already took care of any head/tail that get cut off * by the alignment. */ k = -uint64(s) & uint64(3) - s += uintptr(k) - n -= k - n &= Uint64FromInt32(-Int32FromInt32(4)) + s = s + uintptr(k) + n = n - k + n = n & Uint64FromInt32(-Int32FromInt32(4)) c32 = Uint32FromInt32(-Int32FromInt32(1)) / Uint32FromInt32(255) * uint32(Uint8FromInt32(c)) /* In preparation to copy 32 bytes at a time, aligned on * an 8-byte bounary, fill head/tail up to 28 bytes each. @@ -146157,8 +146157,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { * and avoid writing the same bytes twice as much as is * practical without introducing additional branching. */ k = uint64(24) + uint64(s)&uint64(4) - s += uintptr(k) - n -= k + s = s + uintptr(k) + n = n - k /* If this loop is reached, 28 tail bytes have already been * filled, so any remainder when n drops below 32 can be * safely ignored. */ @@ -146174,8 +146174,8 @@ func Xmemset(tls *TLS, dest uintptr, c int32, n Tsize_t) (r uintptr) { goto _1 _1: ; - n -= uint64(32) - s += uintptr(32) + n = n - uint64(32) + s = s + uintptr(32) } return dest } @@ -146205,8 +146205,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws, v4, v5 uintptr - var v2, v7 uint8 - _, _, _, _, _, _ = wd, ws, v2, v4, v5, v7 + var v2 uint8 + _, _, _, _, _ = wd, ws, v2, v4, v5 if uint64(s)%Uint64FromInt64(8) == uint64(d)%Uint64FromInt64(8) { for { if !(uint64(s)%Uint64FromInt64(8) != 0) { @@ -146220,8 +146220,8 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { goto _1 _1: ; - s++ - d++ + s = s + 1 + d = d + 1 } wd = d ws = s @@ -146242,16 +146242,16 @@ func X__stpcpy(tls *TLS, d uintptr, s uintptr) (r uintptr) { s = ws } for { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 - if !(v7 != 0) { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 + if !(v2 != 0) { break } goto _6 _6: ; - s++ - d++ + s = s + 1 + d = d + 1 } return d } @@ -146290,9 +146290,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var wd, ws uintptr - var v2, v6 uint8 - var v3, v7 bool - _, _, _, _, _, _ = wd, ws, v2, v3, v6, v7 + var v2 uint8 + var v3 bool + _, _, _, _ = wd, ws, v2, v3 if uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) == uint64(d)&(Uint64FromInt64(8)-Uint64FromInt32(1)) { for { if v3 = uint64(s)&(Uint64FromInt64(8)-Uint64FromInt32(1)) != 0 && n != 0; v3 { @@ -146305,9 +146305,9 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if !(n != 0) || !(*(*uint8)(unsafe.Pointer(s)) != 0) { goto tail @@ -146322,7 +146322,7 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { goto _4 _4: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146330,19 +146330,19 @@ func X__stpncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { s = ws } for { - if v7 = n != 0; v7 { - v6 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v6 + if v3 = n != 0; v3 { + v2 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v2 } - if !(v7 && v6 != 0) { + if !(v3 && v2 != 0) { break } goto _5 _5: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } goto tail tail: @@ -146384,8 +146384,8 @@ func Xstrcasecmp(tls *TLS, _l uintptr, _r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146424,7 +146424,7 @@ func Xstrcasestr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - h++ + h = h + 1 } return uintptr(0) } @@ -146487,7 +146487,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _1 _1: ; - s++ + s = s + 1 } k = Uint64FromInt32(-Int32FromInt32(1)) / Uint64FromInt32(UCHAR_MAX) * Uint64FromInt32(c) w = s @@ -146508,7 +146508,7 @@ func X__strchrnul(tls *TLS, s uintptr, c int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } return s } @@ -146542,8 +146542,8 @@ func Xstrcmp(tls *TLS, l uintptr, r uintptr) (r1 int32) { goto _1 _1: ; - l++ - r++ + l = l + 1 + r = r + 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146564,10 +146564,10 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p2 uintptr + var a, v2 uintptr var v3 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v3, p2 + _, _, _ = a, v2, v3 a = s if !(*(*uint8)(unsafe.Pointer(c)) != 0) || !(*(*uint8)(unsafe.Pointer(c + 1)) != 0) { return Uint64FromInt64(int64(X__strchrnul(tls, s, Int32FromUint8(*(*uint8)(unsafe.Pointer(c))))) - int64(a)) @@ -146575,16 +146575,16 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { Xmemset(tls, bp, 0, uint64(32)) for { if v3 = *(*uint8)(unsafe.Pointer(c)) != 0; v3 { - p2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v2 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v2)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v3 && *(*Tsize_t)(unsafe.Pointer(p2)) != 0) { + if !(v3 && *(*Tsize_t)(unsafe.Pointer(v2)) != 0) { break } goto _1 _1: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && !((*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0)) { @@ -146593,7 +146593,7 @@ func Xstrcspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _4 _4: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146675,12 +146675,12 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } var d0, wd, ws uintptr var v1 Tsize_t - var v3, v7 uint8 - var v4, v8 bool - _, _, _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4, v7, v8 + var v3 uint8 + var v4 bool + _, _, _, _, _, _ = d0, wd, ws, v1, v3, v4 d0 = d v1 = n - n-- + n = n - 1 if !(v1 != 0) { goto finish } @@ -146696,9 +146696,9 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _2 _2: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } if n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { wd = d @@ -146711,7 +146711,7 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { goto _5 _5: ; - n -= uint64(8) + n = n - uint64(8) ws += 8 wd += 8 } @@ -146720,19 +146720,19 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r Tsize_t) { } } for { - if v8 = n != 0; v8 { - v7 = *(*uint8)(unsafe.Pointer(s)) - *(*uint8)(unsafe.Pointer(d)) = v7 + if v4 = n != 0; v4 { + v3 = *(*uint8)(unsafe.Pointer(s)) + *(*uint8)(unsafe.Pointer(d)) = v3 } - if !(v8 && v7 != 0) { + if !(v4 && v3 != 0) { break } goto _6 _6: ; - n-- - s++ - d++ + n = n - 1 + s = s + 1 + d = d + 1 } *(*uint8)(unsafe.Pointer(d)) = uint8(0) goto finish @@ -146771,7 +146771,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } w = s for { @@ -146791,7 +146791,7 @@ func Xstrlen(tls *TLS, s uintptr) (r Tsize_t) { goto _3 _3: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } @@ -146807,7 +146807,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146818,9 +146818,9 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(r)))) } @@ -146846,21 +146846,21 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xstrlen(tls, d)) + d = d + uintptr(Xstrlen(tls, d)) for n != 0 && *(*uint8)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d - d++ + d = d + 1 v2 = s - s++ + s = s + 1 *(*uint8)(unsafe.Pointer(v1)) = *(*uint8)(unsafe.Pointer(v2)) } - v3 = d - d++ - *(*uint8)(unsafe.Pointer(v3)) = uint8(0) + v1 = d + d = d + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) return a } @@ -146875,7 +146875,7 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { l = _l r = _r v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -146886,9 +146886,9 @@ func Xstrncmp(tls *TLS, _l uintptr, _r uintptr, n Tsize_t) (r1 int32) { goto _2 _2: ; - l++ - r++ - n-- + l = l + 1 + r = r + 1 + n = n - 1 } return Int32FromUint8(*(*uint8)(unsafe.Pointer(l))) - Int32FromUint8(*(*uint8)(unsafe.Pointer(r))) } @@ -146944,7 +146944,7 @@ func Xstrpbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xstrcspn(tls, s, b)) + s = s + uintptr(Xstrcspn(tls, s, b)) if *(*uint8)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -146975,7 +146975,7 @@ func Xstrsep(tls *TLS, str uintptr, sep uintptr) (r uintptr) { end = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(end)) != 0 { v1 = end - end++ + end = end + 1 *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { end = uintptr(0) @@ -147001,7 +147001,7 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { } for { v2 = signum - signum-- + signum = signum - 1 if !(v2 != 0) { break } @@ -147012,12 +147012,12 @@ func Xstrsignal(tls *TLS, signum int32) (r uintptr) { goto _3 _3: ; - s++ + s = s + 1 } goto _1 _1: ; - s++ + s = s + 1 } return X__lctrans_cur(tls, s) } @@ -147029,10 +147029,10 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } bp := tls.Alloc(32) defer tls.Free(32) - var a, p3 uintptr + var a, v3 uintptr var v4 bool var _ /* byteset at bp+0 */ [4]Tsize_t - _, _, _ = a, v4, p3 + _, _, _ = a, v3, v4 a = s *(*[4]Tsize_t)(unsafe.Pointer(bp)) = [4]Tsize_t{} if !(*(*uint8)(unsafe.Pointer(c)) != 0) { @@ -147046,22 +147046,22 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _1 _1: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } for { if v4 = *(*uint8)(unsafe.Pointer(c)) != 0; v4 { - p3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 - *(*Tsize_t)(unsafe.Pointer(p3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) + v3 = bp + uintptr(uint64(*(*uint8)(unsafe.Pointer(c)))/(Uint64FromInt32(8)*Uint64FromInt64(8)))*8 + *(*Tsize_t)(unsafe.Pointer(v3)) |= Uint64FromInt32(1) << (uint64(*(*uint8)(unsafe.Pointer(c))) % (Uint64FromInt32(8) * Uint64FromInt64(8))) } - if !(v4 && *(*Tsize_t)(unsafe.Pointer(p3)) != 0) { + if !(v4 && *(*Tsize_t)(unsafe.Pointer(v3)) != 0) { break } goto _2 _2: ; - c++ + c = c + 1 } for { if !(*(*uint8)(unsafe.Pointer(s)) != 0 && (*(*[4]Tsize_t)(unsafe.Pointer(bp)))[uint64(*(*uint8)(unsafe.Pointer(s)))/(Uint64FromInt32(8)*Uint64FromInt64(8))]&(Uint64FromInt32(1)<<(uint64(*(*uint8)(unsafe.Pointer(s)))%(Uint64FromInt32(8)*Uint64FromInt64(8)))) != 0) { @@ -147070,18 +147070,18 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { goto _5 _5: ; - s++ + s = s + 1 } return Uint64FromInt64(int64(s) - int64(a)) } func _twobyte_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { var hw, nw Tuint16_t - var v2, v3 uintptr - _, _, _, _ = hw, nw, v2, v3 + var v2 uintptr + _, _, _ = hw, nw, v2 nw = Uint16FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(n)))< Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147213,29 +147213,29 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(ip+k)))) < Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(jp+k)))) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147272,7 +147272,7 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) + z = z + uintptr(grow) } } /* Check last byte first; advance by shift on mismatch */ @@ -147282,22 +147282,22 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { if k < mem { k = mem } - h += uintptr(k) + h = h + uintptr(k) mem = uint64(0) goto _9 } } else { - h += uintptr(l) + h = h + uintptr(l) mem = uint64(0) goto _9 } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(n + uintptr(k)))) == Int32FromUint8(*(*uint8)(unsafe.Pointer(h + uintptr(k))))) { break @@ -147305,10 +147305,10 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*uint8)(unsafe.Pointer(n + uintptr(k))) != 0 { - h += uintptr(k - ms) + h = h + uintptr(k-ms) mem = uint64(0) goto _9 } @@ -147321,12 +147321,12 @@ func _twoway_strstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) + h = h + uintptr(p) mem = mem0 goto _9 _9: @@ -147374,9 +147374,9 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v, (%v:)", tls, s, sep, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4 uintptr + var v1 uintptr var v2 bool - _, _, _, _ = v1, v2, v3, v4 + _, _ = v1, v2 if v2 = !(s != 0); v2 { v1 = _p2 s = v1 @@ -147384,17 +147384,17 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - _p2 = v3 - return v3 + v1 = UintptrFromInt32(0) + _p2 = v1 + return v1 } _p2 = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(_p2)) != 0 { - v4 = _p2 - _p2++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v1 = _p2 + _p2 = _p2 + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { _p2 = uintptr(0) } @@ -147408,9 +147408,9 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -147418,18 +147418,18 @@ func Xstrtok_r(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xstrspn(tls, s, sep)) + s = s + uintptr(Xstrspn(tls, s, sep)) if !(*(*uint8)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xstrcspn(tls, s, sep)) if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5))++ - *(*uint8)(unsafe.Pointer(v4)) = uint8(0) + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) = *(*uintptr)(unsafe.Pointer(v3)) + 1 + *(*uint8)(unsafe.Pointer(v1)) = uint8(0) } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -147472,7 +147472,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _1 _1: ; - i++ + i = i + 1 } if Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(l + uintptr(dp))))-int32('1')) < uint32(9) && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(r + uintptr(dp))))-int32('1')) < uint32(9) { /* If we're looking at non-degenerate digit sequences starting @@ -147488,7 +147488,7 @@ func Xstrverscmp(tls *TLS, l0 uintptr, r0 uintptr) (r1 int32) { goto _3 _3: ; - j++ + j = j + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(r + uintptr(j))))-uint32('0') < uint32(10)) != 0 { return -int32(1) @@ -147517,12 +147517,12 @@ func Xswab(tls *TLS, _src uintptr, _dest uintptr, n Tssize_t) { } *(*uint8)(unsafe.Pointer(dest)) = *(*uint8)(unsafe.Pointer(src + 1)) *(*uint8)(unsafe.Pointer(dest + 1)) = *(*uint8)(unsafe.Pointer(src)) - dest += uintptr(2) - src += uintptr(2) + dest = dest + uintptr(2) + src = src + uintptr(2) goto _1 _1: ; - n -= int64(2) + n = n - int64(2) } } @@ -147722,7 +147722,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { var v1 Tsize_t _ = v1 v1 = n - n-- + n = n - 1 if !(v1 != 0) { return 0 } @@ -147735,7 +147735,7 @@ func Xwcsncasecmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { ; l += 4 r += 4 - n-- + n = n - 1 } return Int32FromUint32(Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(l)))) - Xtowlower(tls, Uint32FromInt32(*(*Twchar_t)(unsafe.Pointer(r))))) } @@ -147753,21 +147753,21 @@ func Xwcsncat(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { trc("tls=%v d=%v s=%v n=%v, (%v:)", tls, d, s, n, origin(2)) defer func() { trc("-> %v", r) }() } - var a, v1, v2, v3 uintptr - _, _, _, _ = a, v1, v2, v3 + var a, v1, v2 uintptr + _, _, _ = a, v1, v2 a = d - d += uintptr(Xwcslen(tls, d)) * 4 + d = d + uintptr(Xwcslen(tls, d))*4 for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s s += 4 *(*Twchar_t)(unsafe.Pointer(v1)) = *(*Twchar_t)(unsafe.Pointer(v2)) } - v3 = d + v1 = d d += 4 - *(*Twchar_t)(unsafe.Pointer(v3)) = 0 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 return a } @@ -147785,7 +147785,7 @@ func Xwcsncmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -147811,7 +147811,7 @@ func Xwcsncpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { _, _, _ = a, v1, v2 a = d for n != 0 && *(*Twchar_t)(unsafe.Pointer(s)) != 0 { - n-- + n = n - 1 v1 = d d += 4 v2 = s @@ -147843,7 +147843,7 @@ func Xwcspbrk(tls *TLS, s uintptr, b uintptr) (r uintptr) { } var v1 uintptr _ = v1 - s += uintptr(Xwcscspn(tls, s, b)) * 4 + s = s + uintptr(Xwcscspn(tls, s, b))*4 if *(*Twchar_t)(unsafe.Pointer(s)) != 0 { v1 = s } else { @@ -147898,10 +147898,10 @@ func Xwcsspn(tls *TLS, s uintptr, c uintptr) (r Tsize_t) { } func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { - var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2, v3, v4, v5, v6, v7 Tsize_t + var grow, ip, jp, k, l, mem, mem0, ms, p, p0, v2 Tsize_t var z, z2 uintptr - var v11, v8 uint64 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v11, v2, v3, v4, v5, v6, v7, v8 + var v8 uint64 + _, _, _, _, _, _, _, _, _, _, _, _, _, _ = grow, ip, jp, k, l, mem, mem0, ms, p, p0, z, z2, v2, v8 /* Computing length of needle */ l = uint64(0) for { @@ -147911,7 +147911,7 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _1 _1: ; - l++ + l = l + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(l)*4)) != 0 { return uintptr(0) @@ -147925,23 +147925,23 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) > *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v3 = jp - jp++ - ip = v3 - v4 = Uint64FromInt32(1) - p = v4 - k = v4 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -147950,29 +147950,29 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { /* And with the opposite comparison */ ip = Uint64FromInt32(-Int32FromInt32(1)) jp = uint64(0) - v5 = Uint64FromInt32(1) - p = v5 - k = v5 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 for jp+k < l { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) == *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { if k == p { - jp += p + jp = jp + p k = uint64(1) } else { - k++ + k = k + 1 } } else { if *(*Twchar_t)(unsafe.Pointer(n + uintptr(ip+k)*4)) < *(*Twchar_t)(unsafe.Pointer(n + uintptr(jp+k)*4)) { - jp += k + jp = jp + k k = uint64(1) p = jp - ip } else { - v6 = jp - jp++ - ip = v6 - v7 = Uint64FromInt32(1) - p = v7 - k = v7 + v2 = jp + jp = jp + 1 + ip = v2 + v2 = Uint64FromInt32(1) + p = v2 + k = v2 } } } @@ -148009,16 +148009,16 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { return uintptr(0) } } else { - z += uintptr(grow) * 4 + z = z + uintptr(grow)*4 } } /* Compare right half */ if ms+uint64(1) > mem { - v11 = ms + uint64(1) + v8 = ms + uint64(1) } else { - v11 = mem + v8 = mem } - k = v11 + k = v8 for { if !(*(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 && *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) == *(*Twchar_t)(unsafe.Pointer(h + uintptr(k)*4))) { break @@ -148026,10 +148026,10 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _10 _10: ; - k++ + k = k + 1 } if *(*Twchar_t)(unsafe.Pointer(n + uintptr(k)*4)) != 0 { - h += uintptr(k-ms) * 4 + h = h + uintptr(k-ms)*4 mem = uint64(0) goto _9 } @@ -148042,12 +148042,12 @@ func _twoway_wcsstr(tls *TLS, h uintptr, n uintptr) (r uintptr) { goto _12 _12: ; - k-- + k = k - 1 } if k <= mem { return h } - h += uintptr(p) * 4 + h = h + uintptr(p)*4 mem = mem0 goto _9 _9: @@ -148083,9 +148083,9 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { trc("tls=%v s=%v sep=%v p=%v, (%v:)", tls, s, sep, p, origin(2)) defer func() { trc("-> %v", r) }() } - var v1, v3, v4, v5 uintptr + var v1, v3 uintptr var v2 bool - _, _, _, _, _ = v1, v2, v3, v4, v5 + _, _, _ = v1, v2, v3 if v2 = !(s != 0); v2 { v1 = *(*uintptr)(unsafe.Pointer(p)) s = v1 @@ -148093,18 +148093,18 @@ func Xwcstok(tls *TLS, s uintptr, sep uintptr, p uintptr) (r uintptr) { if v2 && !(v1 != 0) { return UintptrFromInt32(0) } - s += uintptr(Xwcsspn(tls, s, sep)) * 4 + s = s + uintptr(Xwcsspn(tls, s, sep))*4 if !(*(*Twchar_t)(unsafe.Pointer(s)) != 0) { - v3 = UintptrFromInt32(0) - *(*uintptr)(unsafe.Pointer(p)) = v3 - return v3 + v1 = UintptrFromInt32(0) + *(*uintptr)(unsafe.Pointer(p)) = v1 + return v1 } *(*uintptr)(unsafe.Pointer(p)) = s + uintptr(Xwcscspn(tls, s, sep))*4 if *(*Twchar_t)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)))) != 0 { - v5 = p - v4 = *(*uintptr)(unsafe.Pointer(v5)) - *(*uintptr)(unsafe.Pointer(v5)) += 4 - *(*Twchar_t)(unsafe.Pointer(v4)) = 0 + v3 = p + v1 = *(*uintptr)(unsafe.Pointer(v3)) + *(*uintptr)(unsafe.Pointer(v3)) += 4 + *(*Twchar_t)(unsafe.Pointer(v1)) = 0 } else { *(*uintptr)(unsafe.Pointer(p)) = uintptr(0) } @@ -148133,7 +148133,7 @@ func Xwmemchr(tls *TLS, s uintptr, c Twchar_t, n Tsize_t) (r uintptr) { goto _1 _1: ; - n-- + n = n - 1 s += 4 } if n != 0 { @@ -148158,7 +148158,7 @@ func Xwmemcmp(tls *TLS, l uintptr, r uintptr, n Tsize_t) (r1 int32) { goto _1 _1: ; - n-- + n = n - 1 l += 4 r += 4 } @@ -148186,7 +148186,7 @@ func Xwmemcpy(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { a = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148205,8 +148205,8 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { defer func() { trc("-> %v", r) }() } var d0, v3, v4 uintptr - var v1, v2 Tsize_t - _, _, _, _, _ = d0, v1, v2, v3, v4 + var v1 Tsize_t + _, _, _, _ = d0, v1, v3, v4 d0 = d if d == s { return d @@ -148214,7 +148214,7 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { if uint64(d)-uint64(s) < n*uint64(4) { for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148222,9 +148222,9 @@ func Xwmemmove(tls *TLS, d uintptr, s uintptr, n Tsize_t) (r uintptr) { } } else { for { - v2 = n - n-- - if !(v2 != 0) { + v1 = n + n = n - 1 + if !(v1 != 0) { break } v3 = d @@ -148248,7 +148248,7 @@ func Xwmemset(tls *TLS, d uintptr, c Twchar_t, n Tsize_t) (r uintptr) { ret = d for { v1 = n - n-- + n = n - 1 if !(v1 != 0) { break } @@ -148281,7 +148281,7 @@ func Xmkdtemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148306,27 +148306,27 @@ func X__mkostemps(tls *TLS, template uintptr, len1 int32, flags int32) (r int32) } bp := tls.Alloc(16) defer tls.Free(16) - var fd, retries, v1, v3 int32 + var fd, retries, v1 int32 var l Tsize_t - _, _, _, _, _ = fd, l, retries, v1, v3 + _, _, _, _ = fd, l, retries, v1 l = Xstrlen(tls, template) if l < uint64(6) || Uint64FromInt32(len1) > l-uint64(6) || Xmemcmp(tls, template+uintptr(l)-uintptr(len1)-uintptr(6), __ccgo_ts+1760, uint64(6)) != 0 { *(*int32)(unsafe.Pointer(X__errno_location(tls))) = int32(EINVAL) return -int32(1) } - flags -= flags & (Int32FromInt32(03) | Int32FromInt32(O_PATH)) + flags = flags - flags&(Int32FromInt32(03)|Int32FromInt32(O_PATH)) retries = int32(100) for { ___randname(tls, template+uintptr(l)-uintptr(len1)-uintptr(6)) - v3 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) - fd = v3 - if v3 >= 0 { + v1 = Xopen(tls, template, flags|int32(O_RDWR)|int32(O_CREAT)|int32(O_EXCL), VaList(bp+8, int32(0600))) + fd = v1 + if v1 >= 0 { return fd } goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0 && *(*int32)(unsafe.Pointer(X__errno_location(tls))) == int32(EEXIST)) { break @@ -148389,7 +148389,7 @@ func Xmktemp(tls *TLS, template uintptr) (r uintptr) { goto _2 _2: ; - retries-- + retries = retries - 1 v1 = retries if !(v1 != 0) { break @@ -148600,7 +148600,7 @@ func X__month_to_secs(tls *TLS, month int32, is_leap int32) (r int32) { _ = t t = _secs_through_month[month] if is_leap != 0 && month >= int32(2) { - t += int32(86400) + t = t + int32(86400) } return t } @@ -148651,38 +148651,38 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { days = secs / int64(86400) remsecs = int32(secs % int64(86400)) if remsecs < 0 { - remsecs += int32(86400) - days-- + remsecs = remsecs + int32(86400) + days = days - 1 } wday = int32((int64(3) + days) % int64(7)) if wday < 0 { - wday += int32(7) + wday = wday + int32(7) } qc_cycles = int32(days / int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) remdays = int32(days % int64(Int32FromInt32(365)*Int32FromInt32(400)+Int32FromInt32(97))) if remdays < 0 { - remdays += Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97) - qc_cycles-- + remdays = remdays + (Int32FromInt32(365)*Int32FromInt32(400) + Int32FromInt32(97)) + qc_cycles = qc_cycles - 1 } c_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) if c_cycles == int32(4) { - c_cycles-- + c_cycles = c_cycles - 1 } - remdays -= c_cycles * (Int32FromInt32(365)*Int32FromInt32(100) + Int32FromInt32(24)) + remdays = remdays - c_cycles*(Int32FromInt32(365)*Int32FromInt32(100)+Int32FromInt32(24)) q_cycles = remdays / (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) if q_cycles == int32(25) { - q_cycles-- + q_cycles = q_cycles - 1 } - remdays -= q_cycles * (Int32FromInt32(365)*Int32FromInt32(4) + Int32FromInt32(1)) + remdays = remdays - q_cycles*(Int32FromInt32(365)*Int32FromInt32(4)+Int32FromInt32(1)) remyears = remdays / int32(365) if remyears == int32(4) { - remyears-- + remyears = remyears - 1 } - remdays -= remyears * int32(365) + remdays = remdays - remyears*int32(365) leap = BoolInt32(!(remyears != 0) && (q_cycles != 0 || !(c_cycles != 0))) yday = remdays + int32(31) + int32(28) + leap if yday >= int32(365)+leap { - yday -= int32(365) + leap + yday = yday - (int32(365) + leap) } years = int64(remyears+int32(4)*q_cycles+int32(100)*c_cycles) + int64(400)*int64(qc_cycles) months = 0 @@ -148690,15 +148690,15 @@ func X__secs_to_tm(tls *TLS, t int64, tm uintptr) (r int32) { if !(Int32FromUint8(_days_in_month[months]) <= remdays) { break } - remdays -= Int32FromUint8(_days_in_month[months]) + remdays = remdays - Int32FromUint8(_days_in_month[months]) goto _1 _1: ; - months++ + months = months + 1 } if months >= int32(10) { - months -= int32(12) - years++ + months = months - int32(12) + years = years + 1 } if years+int64(100) > int64(INT_MAX) || years+int64(100) < int64(-Int32FromInt32(1)-Int32FromInt32(0x7fffffff)) { return -int32(1) @@ -148744,19 +148744,19 @@ func X__tm_to_secs(tls *TLS, tm uintptr) (r int64) { month = (*Ttm)(unsafe.Pointer(tm)).Ftm_mon if month >= int32(12) || month < 0 { adj = month / int32(12) - month %= int32(12) + month = month % int32(12) if month < 0 { - adj-- - month += int32(12) + adj = adj - 1 + month = month + int32(12) } - year += int64(adj) + year = year + int64(adj) } t = X__year_to_secs(tls, year, bp) - t += int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) - t += int64(86400) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) - t += int64(3600) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) - t += int64(60) * int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) - t += int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) + t = t + int64(X__month_to_secs(tls, month, *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(86400)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_mday-Int32FromInt32(1)) + t = t + int64(3600)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_hour) + t = t + int64(60)*int64((*Ttm)(unsafe.Pointer(tm)).Ftm_min) + t = t + int64((*Ttm)(unsafe.Pointer(tm)).Ftm_sec) return t } @@ -148793,7 +148793,7 @@ func _getint2(tls *TLS, p uintptr) (r int32) { goto _1 _1: ; - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } return Int32FromUint32(x) } @@ -148803,20 +148803,20 @@ func _getoff(tls *TLS, p uintptr) (r int32) { _, _, _ = neg, off, v1 neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('-') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 neg = int32(1) } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('+') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } off = int32(3600) * _getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += int32(60) * _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + int32(60)*_getint2(tls, p) if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(p))++ - off += _getint2(tls, p) + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 + off = off + _getint2(tls, p) } } if neg != 0 { @@ -148835,21 +148835,21 @@ func _getrule(tls *TLS, p uintptr, rule uintptr) { r = v1 if r != int32('M') { if r == int32('J') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } else { *(*int32)(unsafe.Pointer(rule)) = 0 } *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) } else { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 1*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 2*4)) = _getint2(tls, p) - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 3*4)) = _getint2(tls, p) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('/') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 *(*int32)(unsafe.Pointer(rule + 4*4)) = _getoff(tls, p) } else { *(*int32)(unsafe.Pointer(rule + 4*4)) = int32(7200) @@ -148860,7 +148860,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { var i, v3 int32 _, _ = i, v3 if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p))))) == int32('<') { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 i = 0 for { if !(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 && Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i)))) != int32('>')) { @@ -148872,10 +148872,10 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _1 _1: ; - i++ + i = i + 1 } if *(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(p)) + uintptr(i))) != 0 { - *(*uintptr)(unsafe.Pointer(p))++ + *(*uintptr)(unsafe.Pointer(p)) = *(*uintptr)(unsafe.Pointer(p)) + 1 } } else { i = 0 @@ -148889,7 +148889,7 @@ func _getname(tls *TLS, d uintptr, p uintptr) { goto _2 _2: ; - i++ + i = i + 1 } } *(*uintptr)(unsafe.Pointer(p)) += uintptr(i) @@ -148915,13 +148915,13 @@ func _zi_dotprod(tls *TLS, z uintptr, v uintptr, n Tsize_t) (r Tsize_t) { break } x = _zi_read32(tls, z) - y += uint64(x * uint32(*(*uint8)(unsafe.Pointer(v)))) + y = y + uint64(x*uint32(*(*uint8)(unsafe.Pointer(v)))) goto _1 _1: ; - n-- - z += uintptr(4) - v++ + n = n - 1 + z = z + uintptr(4) + v = v + 1 } return y } @@ -148931,13 +148931,13 @@ func _do_tzset(tls *TLS) { defer tls.Free(320) var i, l, skip Tsize_t var map1, p1, pathname, try, v5 uintptr - var posix_form, scale, v2, v7 int32 + var posix_form, scale, v2 int32 var v6 int64 var _ /* buf at bp+6 */ [280]uint8 var _ /* dummy_name at bp+308 */ [7]uint8 var _ /* p at bp+296 */ uintptr var _ /* s at bp+288 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6, v7 + _, _, _, _, _, _, _, _, _, _, _, _ = i, l, map1, p1, pathname, posix_form, scale, skip, try, v2, v5, v6 pathname = bp + 6 + uintptr(24) map1 = uintptr(0) *(*uintptr)(unsafe.Pointer(bp + 288)) = Xgetenv(tls, __ccgo_ts+1767) @@ -148961,7 +148961,7 @@ func _do_tzset(tls *TLS) { goto _1 _1: ; - i++ + i = i + 1 } if _zi != 0 { X__munmap(tls, _zi, _map_size) @@ -148975,7 +148975,7 @@ func _do_tzset(tls *TLS) { i = Uint64FromInt32(3) } if i >= _old_tz_size { - _old_tz_size *= uint64(2) + _old_tz_size = _old_tz_size * uint64(2) if i >= _old_tz_size { _old_tz_size = i + uint64(1) } @@ -149000,7 +149000,7 @@ func _do_tzset(tls *TLS) { * standard path will be searched. */ if !(posix_form != 0) { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(':') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('/') || Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32('.') { if !(X__libc.Fsecure != 0) || !(Xstrcmp(tls, *(*uintptr)(unsafe.Pointer(bp + 288)), __ccgo_ts+1770) != 0) { @@ -149022,7 +149022,7 @@ func _do_tzset(tls *TLS) { goto _3 _3: ; - try += uintptr(l + uint64(1)) + try = try + uintptr(l+uint64(1)) } } } @@ -149049,7 +149049,7 @@ func _do_tzset(tls *TLS) { } skip = _zi_dotprod(tls, _zi+uintptr(20), bp, uint64(6)) _trans = _zi + uintptr(skip) + uintptr(44) + uintptr(44) - scale++ + scale = scale + 1 } else { _trans = _zi + uintptr(44) } @@ -149066,16 +149066,16 @@ func _do_tzset(tls *TLS) { goto _4 _4: ; - *(*uintptr)(unsafe.Pointer(bp + 288))-- + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) - 1 } - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 } else { v5 = UintptrFromInt32(0) Xtzname[int32(1)] = v5 Xtzname[0] = v5 - v7 = Int32FromInt32(0) - _dst_off = v7 - v6 = int64(v7) + v2 = Int32FromInt32(0) + _dst_off = v2 + v6 = int64(v2) Xtimezone = v6 Xdaylight = int32(v6) p1 = _types @@ -149095,7 +149095,7 @@ func _do_tzset(tls *TLS) { goto _8 _8: ; - p1 += uintptr(6) + p1 = p1 + uintptr(6) } if !(Xtzname[0] != 0) { Xtzname[0] = Xtzname[int32(1)] @@ -149130,11 +149130,11 @@ func _do_tzset(tls *TLS) { _dst_off = int32(Xtimezone) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r0))) } if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 288))))) == int32(',') { - *(*uintptr)(unsafe.Pointer(bp + 288))++ + *(*uintptr)(unsafe.Pointer(bp + 288)) = *(*uintptr)(unsafe.Pointer(bp + 288)) + 1 _getrule(tls, bp+288, uintptr(unsafe.Pointer(&_r12))) } } @@ -149172,10 +149172,10 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(int32(6)*Int32FromUint8(*(*uint8)(unsafe.Pointer(_index + uintptr(m-uint64(1)))))))) } if t-int64(off) < int64(Int64FromUint64(x)) { - n /= uint64(2) + n = n / uint64(2) } else { a = m - n -= n / uint64(2) + n = n - n/uint64(2) } } /* First and last entry are special. First means to use lowest-index @@ -149204,7 +149204,7 @@ func _scan_trans(tls *TLS, t int64, local int32, alt uintptr) (r Tsize_t) { goto _1 _1: ; - i -= uint64(6) + i = i - uint64(6) } if local != 0 { off = Int32FromUint32(_zi_read32(tls, _types+uintptr(j))) @@ -149255,25 +149255,25 @@ func _rule_to_secs(tls *TLS, rule uintptr, year int32) (r int64) { if *(*int32)(unsafe.Pointer(rule)) != int32('M') { x = *(*int32)(unsafe.Pointer(rule + 1*4)) if *(*int32)(unsafe.Pointer(rule)) == int32('J') && (x < int32(60) || !(*(*int32)(unsafe.Pointer(bp)) != 0)) { - x-- + x = x - 1 } - t += int64(int32(86400) * x) + t = t + int64(int32(86400)*x) } else { m = *(*int32)(unsafe.Pointer(rule + 1*4)) n = *(*int32)(unsafe.Pointer(rule + 2*4)) d = *(*int32)(unsafe.Pointer(rule + 3*4)) - t += int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) + t = t + int64(X__month_to_secs(tls, m-int32(1), *(*int32)(unsafe.Pointer(bp)))) wday = int32((t+int64(Int32FromInt32(4)*Int32FromInt32(86400)))%int64(Int32FromInt32(7)*Int32FromInt32(86400))) / int32(86400) days = d - wday if days < 0 { - days += int32(7) + days = days + int32(7) } if n == int32(5) && days+int32(28) >= _days_in_month1(tls, m, *(*int32)(unsafe.Pointer(bp))) { n = int32(4) } - t += int64(int32(86400) * (days + int32(7)*(n-int32(1)))) + t = t + int64(int32(86400)*(days+int32(7)*(n-int32(1)))) } - t += int64(*(*int32)(unsafe.Pointer(rule + 4*4))) + t = t + int64(*(*int32)(unsafe.Pointer(rule + 4*4))) return t } @@ -149316,16 +149316,16 @@ func X__secs_to_zone(tls *TLS, t int64, local int32, isdst uintptr, offset uintp * Also, this could be more efficient.*/ y = t/int64(31556952) + int64(70) for X__year_to_secs(tls, y, uintptr(0)) > t { - y-- + y = y - 1 } for X__year_to_secs(tls, y+int64(1), uintptr(0)) < t { - y++ + y = y + 1 } t0 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r0)), int32(y)) t1 = _rule_to_secs(tls, uintptr(unsafe.Pointer(&_r12)), int32(y)) if !(local != 0) { - t0 += Xtimezone - t1 += int64(_dst_off) + t0 = t0 + Xtimezone + t1 = t1 + int64(_dst_off) } if t0 < t1 { if t >= t0 && t < t1 { @@ -149398,7 +149398,7 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { y = int32(year) leaps = (y - int32(68)) >> int32(2) if !((y-Int32FromInt32(68))&Int32FromInt32(3) != 0) { - leaps-- + leaps = leaps - 1 if is_leap != 0 { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) } @@ -149415,8 +149415,8 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { cycles = int32((year - int64(100)) / int64(400)) rem = int32((year - int64(100)) % int64(400)) if rem < 0 { - cycles-- - rem += int32(400) + cycles = cycles - 1 + rem = rem + int32(400) } if !(rem != 0) { *(*int32)(unsafe.Pointer(is_leap)) = int32(1) @@ -149426,15 +149426,15 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { if rem >= int32(200) { if rem >= int32(300) { centuries = int32(3) - rem -= int32(300) + rem = rem - int32(300) } else { centuries = int32(2) - rem -= int32(200) + rem = rem - int32(200) } } else { if rem >= int32(100) { centuries = int32(1) - rem -= int32(100) + rem = rem - int32(100) } else { centuries = 0 } @@ -149444,11 +149444,11 @@ func X__year_to_secs(tls *TLS, year int64, is_leap uintptr) (r int64) { leaps1 = 0 } else { leaps1 = Int32FromUint32(Uint32FromInt32(rem) / uint32(4)) - rem = int32(uint32(rem) % Uint32FromUint32(4)) + rem = Int32FromUint32(uint32(rem) % Uint32FromUint32(4)) *(*int32)(unsafe.Pointer(is_leap)) = BoolInt32(!(rem != 0)) } } - leaps1 += int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap)) + leaps1 = leaps1 + (int32(97)*cycles + int32(24)*centuries - *(*int32)(unsafe.Pointer(is_leap))) return (year-int64(100))*int64(31536000) + int64(leaps1)*int64(86400) + int64(946684800) + int64(86400) } @@ -149845,9 +149845,9 @@ func Xmktime(tls *TLS, tm uintptr) (r Ttime_t) { t = X__tm_to_secs(tls, tm) X__secs_to_zone(tls, t, int32(1), bp+32, bp+40, bp+56, bp+48) if (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst >= 0 && (*(*Ttm)(unsafe.Pointer(bp))).Ftm_isdst != (*Ttm)(unsafe.Pointer(tm)).Ftm_isdst { - t -= *(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*int64)(unsafe.Pointer(bp + 56)) - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff) } - t -= (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff + t = t - (*(*Ttm)(unsafe.Pointer(bp))).F__tm_gmtoff if t != t { goto error } @@ -149875,9 +149875,9 @@ func Xnanosleep(tls *TLS, req uintptr, rem uintptr) (r int32) { func _is_leap(tls *TLS, y int32) (r int32) { /* Avoid overflow */ if y > Int32FromInt32(INT_MAX)-Int32FromInt32(1900) { - y -= int32(2000) + y = y - int32(2000) } - y += int32(1900) + y = y + int32(1900) return BoolInt32(!(y%Int32FromInt32(4) != 0) && (y%int32(100) != 0 || !(y%Int32FromInt32(400) != 0))) } @@ -149888,7 +149888,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { /* If 1 Jan is just 1-3 days past Monday, * the previous week is also in this year. */ if (Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday)+uint32(371)-Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday)-uint32(2))%uint32(7) <= uint32(2) { - val++ + val = val + 1 } if !(val != 0) { val = int32(52) @@ -149897,7 +149897,7 @@ func _week_num(tls *TLS, tm uintptr) (r int32) { * prev year has 53 weeks. */ dec31 = Int32FromUint32((Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_wday) + uint32(7) - Uint32FromInt32((*Ttm)(unsafe.Pointer(tm)).Ftm_yday) - uint32(1)) % uint32(7)) if dec31 == int32(4) || dec31 == int32(5) && _is_leap(tls, (*Ttm)(unsafe.Pointer(tm)).Ftm_year%int32(400)-int32(1)) != 0 { - val++ + val = val + 1 } } else { if val == int32(53) { @@ -149921,10 +149921,10 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc bp := tls.Alloc(32) defer tls.Free(32) var d, fmt, v4, v5 uintptr - var def_pad, width, v1, v2, v6, v7 int32 + var def_pad, width, v1 int32 var item Tnl_item var val int64 - _, _, _, _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v2, v4, v5, v6, v7 + _, _, _, _, _, _, _, _, _ = d, def_pad, fmt, item, val, width, v1, v4, v5 fmt = __ccgo_ts + 1692 width = int32(2) def_pad = int32('0') @@ -149978,14 +149978,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc case int32('G'): val = int64((*Ttm)(unsafe.Pointer(tm)).Ftm_year) + int64(1900) if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday < int32(3) && _week_num(tls, tm) != int32(1) { - val-- + val = val - 1 } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_yday > int32(360) && _week_num(tls, tm) == int32(1) { - val++ + val = val + 1 } } if f == int32('g') { - val %= int64(100) + val = val % int64(100) } else { width = int32(4) } @@ -150002,7 +150002,7 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc val = int64(12) } else { if val > int64(12) { - val -= int64(12) + val = val - int64(12) } } goto number @@ -150033,11 +150033,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto nl_strcat case int32('P'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_hour >= int32(12) { - v2 = int32(PM_STR) + v1 = int32(PM_STR) } else { - v2 = int32(AM_STR) + v1 = int32(AM_STR) } - item = v2 + item = v1 fmt = X__nl_langinfo_l(tls, item, loc) d = s *(*Tsize_t)(unsafe.Pointer(l)) = uint64(0) @@ -150046,14 +150046,14 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc break } v4 = d - d++ + d = d + 1 v5 = fmt - fmt++ + fmt = fmt + 1 *(*uint8)(unsafe.Pointer(v4)) = Uint8FromInt32(Xtolower(tls, Int32FromUint8(*(*uint8)(unsafe.Pointer(v5))))) goto _3 _3: ; - *(*Tsize_t)(unsafe.Pointer(l))++ + *(*Tsize_t)(unsafe.Pointer(l)) = *(*Tsize_t)(unsafe.Pointer(l)) + 1 } return s case int32('r'): @@ -150077,11 +150077,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc goto recu_strftime case int32('u'): if (*Ttm)(unsafe.Pointer(tm)).Ftm_wday != 0 { - v6 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday + v1 = (*Ttm)(unsafe.Pointer(tm)).Ftm_wday } else { - v6 = int32(7) + v1 = int32(7) } - val = int64(v6) + val = int64(v1) width = int32(1) goto number case int32('U'): @@ -150141,11 +150141,11 @@ func X__strftime_fmt_1(tls *TLS, s uintptr, l uintptr, f int32, tm uintptr, loc number: ; if pad != 0 { - v7 = pad + v1 = pad } else { - v7 = def_pad + v1 = def_pad } - switch v7 { + switch v1 { case int32('-'): *(*Tsize_t)(unsafe.Pointer(l)) = Uint64FromInt32(Xsnprintf(tls, s, uint64(100), __ccgo_ts+1896, VaList(bp+8, val))) case int32('_'): @@ -150187,15 +150187,15 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(128) defer tls.Free(128) - var d, l, v10, v12, v2, v7 Tsize_t - var pad, plus, v4, v8 int32 + var d, l, v2 Tsize_t + var pad, plus, v4 int32 var t, v3 uintptr var width uint64 var v9 bool var _ /* buf at bp+8 */ [100]uint8 var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+112 */ uintptr - _, _, _, _, _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v10, v12, v2, v3, v4, v7, v8, v9 + _, _, _, _, _, _, _, _, _, _ = d, l, pad, plus, t, width, v2, v3, v4, v9 l = uint64(0) for { if !(l < n) { @@ -150207,21 +150207,21 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) != int32('%') { v2 = l - l++ + l = l + 1 *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = *(*uint8)(unsafe.Pointer(f)) goto _1 } - f++ + f = f + 1 pad = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('-') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('_') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('0') { v3 = f - f++ + f = f + 1 pad = Int32FromUint8(*(*uint8)(unsafe.Pointer(v3))) } v4 = BoolInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == Int32FromUint8('+')) plus = v4 if v4 != 0 { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { width = Xstrtoul(tls, f, bp+112, int32(10)) @@ -150238,7 +150238,7 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } f = *(*uintptr)(unsafe.Pointer(bp + 112)) if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('E') || Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('O') { - f++ + f = f + 1 } t = X__strftime_fmt_1(tls, bp+8, bp, Int32FromUint8(*(*uint8)(unsafe.Pointer(f))), tm, loc, pad) if !(t != 0) { @@ -150249,8 +150249,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl * count remaining digits to determine behavior * for the + flag. */ if Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('+') || Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('-') { - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } for { if !(Int32FromUint8(*(*uint8)(unsafe.Pointer(t))) == int32('0') && Uint32FromInt32(Int32FromUint8(*(*uint8)(unsafe.Pointer(t + 1)))-int32('0')) < uint32(10)) { @@ -150259,8 +150259,8 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _5 _5: ; - t++ - *(*Tsize_t)(unsafe.Pointer(bp))-- + t = t + 1 + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } if width < *(*Tsize_t)(unsafe.Pointer(bp)) { width = *(*Tsize_t)(unsafe.Pointer(bp)) @@ -150273,50 +150273,50 @@ func X__strftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl goto _6 _6: ; - d++ + d = d + 1 } if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v7))) = uint8('-') - width-- + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('-') + width = width - 1 } else { if v9 = plus != 0; v9 { if Int32FromUint8(*(*uint8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 112))))) == int32('C') { - v8 = int32(3) + v4 = int32(3) } else { - v8 = int32(5) + v4 = int32(5) } } - if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v8) { - v10 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v10))) = uint8('+') - width-- + if v9 && d+(width-*(*Tsize_t)(unsafe.Pointer(bp))) >= Uint64FromInt32(v4) { + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('+') + width = width - 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v12 = l - l++ - *(*uint8)(unsafe.Pointer(s + uintptr(v12))) = uint8('0') + v2 = l + l = l + 1 + *(*uint8)(unsafe.Pointer(s + uintptr(v2))) = uint8('0') goto _11 _11: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) > n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xmemcpy(tls, s+uintptr(l), t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; - f++ + f = f + 1 } if n != 0 { if l == n { @@ -150350,15 +150350,15 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } bp := tls.Alloc(32) defer tls.Free(32) - var adj, i, min, neg, range1, w, want_century, v1, v2, v45, v46, v5, v53, v6 int32 - var dest, ex, v49, v51, v54, v9 uintptr + var adj, i, min, neg, range1, w, want_century, v1, v2, v5, v6 int32 + var dest, ex, v9 uintptr var len1 Tsize_t - var v48, v8 bool + var v8 bool var _ /* century at bp+4 */ int32 var _ /* dummy at bp+0 */ int32 var _ /* new_f at bp+16 */ uintptr var _ /* relyear at bp+8 */ int32 - _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v45, v46, v48, v49, v5, v51, v53, v54, v6, v8, v9 + _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = adj, dest, ex, i, len1, min, neg, range1, w, want_century, v1, v2, v5, v6, v8, v9 want_century = 0 *(*int32)(unsafe.Pointer(bp + 4)) = 0 *(*int32)(unsafe.Pointer(bp + 8)) = 0 @@ -150382,21 +150382,21 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto _4 _4: ; - s++ + s = s + 1 } } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) != Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) { return uintptr(0) } else { - s++ + s = s + 1 } } - f++ + f = f + 1 continue } - f++ + f = f + 1 if Int32FromUint8(*(*uint8)(unsafe.Pointer(f))) == int32('+') { - f++ + f = f + 1 } if BoolInt32(uint32(*(*uint8)(unsafe.Pointer(f)))-uint32('0') < uint32(10)) != 0 { w = Int32FromUint64(Xstrtoul(tls, f, bp+16, int32(10))) @@ -150406,7 +150406,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { } adj = 0 v9 = f - f++ + f = f + 1 switch Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) { case int32('A'): goto _10 @@ -150503,7 +150503,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if w < 0 { w = int32(2) } - want_century |= int32(2) + want_century = want_century | int32(2) goto numeric_digits _18: ; @@ -150558,19 +150558,19 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; _44: ; - if v48 = *(*uint8)(unsafe.Pointer(s)) != 0; v48 { - v45 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) - v46 = BoolInt32(v45 == int32(' ') || Uint32FromInt32(v45)-uint32('\t') < uint32(5)) + if v8 = *(*uint8)(unsafe.Pointer(s)) != 0; v8 { + v1 = Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) + v2 = BoolInt32(v1 == int32(' ') || Uint32FromInt32(v1)-uint32('\t') < uint32(5)) goto _47 _47: } - if !(v48 && v46 != 0) { + if !(v8 && v2 != 0) { goto _42 } goto _43 _43: ; - s++ + s = s + 1 goto _44 goto _42 _42: @@ -150582,7 +150582,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { len1 = Xstrlen(tls, ex) if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } ex = Xnl_langinfo(tls, int32(PM_STR)) @@ -150590,7 +150590,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(Xstrncasecmp(tls, s, ex, len1) != 0) { *(*int32)(unsafe.Pointer(tm + 8)) %= int32(12) *(*int32)(unsafe.Pointer(tm + 8)) += int32(12) - s += uintptr(len1) + s = s + uintptr(len1) goto _41 } return uintptr(0) @@ -150654,7 +150654,7 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; dest = bp + 8 w = int32(2) - want_century |= int32(1) + want_century = want_century | int32(1) goto numeric_digits _38: ; @@ -150667,9 +150667,9 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { goto numeric_digits _39: ; - v49 = s - s++ - if Int32FromUint8(*(*uint8)(unsafe.Pointer(v49))) != int32('%') { + v9 = s + s = s + 1 + if Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) != int32('%') { return uintptr(0) } goto _41 @@ -150688,13 +150688,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if !(i <= min+range1 && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v51 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v51))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _50 _50: ; - i *= int32(10) + i = i * int32(10) } if Uint32FromInt32(*(*int32)(unsafe.Pointer(dest))-min) >= Uint32FromInt32(range1) { return uintptr(0) @@ -150709,30 +150709,30 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { ; neg = 0 if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('+') { - s++ + s = s + 1 } else { if Int32FromUint8(*(*uint8)(unsafe.Pointer(s))) == int32('-') { neg = int32(1) - s++ + s = s + 1 } } if !(BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-Uint32FromUint8('0') < Uint32FromInt32(10)) != 0) { return uintptr(0) } - v53 = Int32FromInt32(0) - i = v53 - *(*int32)(unsafe.Pointer(dest)) = v53 + v1 = Int32FromInt32(0) + i = v1 + *(*int32)(unsafe.Pointer(dest)) = v1 for { if !(i < w && BoolInt32(uint32(*(*uint8)(unsafe.Pointer(s)))-uint32('0') < uint32(10)) != 0) { break } - v54 = s - s++ - *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v54))) - int32('0') + v9 = s + s = s + 1 + *(*int32)(unsafe.Pointer(dest)) = *(*int32)(unsafe.Pointer(dest))*int32(10) + Int32FromUint8(*(*uint8)(unsafe.Pointer(v9))) - int32('0') goto _52 _52: ; - i++ + i = i + 1 } if neg != 0 { *(*int32)(unsafe.Pointer(dest)) = -*(*int32)(unsafe.Pointer(dest)) @@ -150752,13 +150752,13 @@ func Xstrptime(tls *TLS, s uintptr, f uintptr, tm uintptr) (r uintptr) { if Xstrncasecmp(tls, s, ex, len1) != 0 { goto _55 } - s += uintptr(len1) + s = s + uintptr(len1) *(*int32)(unsafe.Pointer(dest)) = i % range1 break goto _55 _55: ; - i-- + i = i - 1 } if i < 0 { return uintptr(0) @@ -150957,7 +150957,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } bp := tls.Alloc(528) defer tls.Free(528) - var l, v2, v6, v7, v9 Tsize_t + var l, v2 Tsize_t var pad, plus, v4 int32 var t, t_mb, v3 uintptr var width uint64 @@ -150965,7 +150965,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl var _ /* k at bp+0 */ Tsize_t var _ /* p at bp+512 */ uintptr var _ /* wbuf at bp+108 */ [100]Twchar_t - _, _, _, _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4, v6, v7, v9 + _, _, _, _, _, _, _, _, _ = l, pad, plus, t, t_mb, width, v2, v3, v4 l = uint64(0) for { if !(l < n) { @@ -150977,7 +150977,7 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl } if *(*Twchar_t)(unsafe.Pointer(f)) != int32('%') { v2 = l - l++ + l = l + 1 *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = *(*Twchar_t)(unsafe.Pointer(f)) goto _1 } @@ -151023,40 +151023,40 @@ func X__wcsftime_l(tls *TLS, s uintptr, n Tsize_t, f uintptr, tm uintptr, loc Tl _5: ; t += 4 - *(*Tsize_t)(unsafe.Pointer(bp))-- + *(*Tsize_t)(unsafe.Pointer(bp)) = *(*Tsize_t)(unsafe.Pointer(bp)) - 1 } - width-- + width = width - 1 if plus != 0 && (*Ttm)(unsafe.Pointer(tm)).Ftm_year >= Int32FromInt32(10000)-Int32FromInt32(1900) { - v6 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v6)*4)) = int32('+') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('+') } else { if (*Ttm)(unsafe.Pointer(tm)).Ftm_year < -int32(1900) { - v7 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v7)*4)) = int32('-') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('-') } else { - width++ + width = width + 1 } } for { if !(width > *(*Tsize_t)(unsafe.Pointer(bp)) && l < n) { break } - v9 = l - l++ - *(*Twchar_t)(unsafe.Pointer(s + uintptr(v9)*4)) = int32('0') + v2 = l + l = l + 1 + *(*Twchar_t)(unsafe.Pointer(s + uintptr(v2)*4)) = int32('0') goto _8 _8: ; - width-- + width = width - 1 } } if *(*Tsize_t)(unsafe.Pointer(bp)) >= n-l { *(*Tsize_t)(unsafe.Pointer(bp)) = n - l } Xwmemcpy(tls, s+uintptr(l)*4, t, *(*Tsize_t)(unsafe.Pointer(bp))) - l += *(*Tsize_t)(unsafe.Pointer(bp)) + l = l + *(*Tsize_t)(unsafe.Pointer(bp)) goto _1 _1: ; @@ -151209,8 +151209,8 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { trc("tls=%v old=%v new1=%v flags=%v, (%v:)", tls, old, new1, flags, origin(2)) defer func() { trc("-> %v", r1) }() } - var r, v1, v2 int32 - _, _, _ = r, v1, v2 + var r, v1 int32 + _, _ = r, v1 if old == new1 { return int32(X__syscall_ret(tls, Uint64FromInt32(-Int32FromInt32(EINVAL)))) } @@ -151230,9 +151230,9 @@ func X__dup3(tls *TLS, old int32, new1 int32, flags int32) (r1 int32) { } } for { - v2 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) - r = v2 - if !(v2 == -int32(EBUSY)) { + v1 = int32(X__syscall2(tls, int64(SYS_dup2), int64(old), int64(new1))) + r = v1 + if !(v1 == -int32(EBUSY)) { break } } @@ -151464,7 +151464,7 @@ func Xgethostname(tls *TLS, name uintptr, len1 Tsize_t) (r int32) { goto _1 _1: ; - i++ + i = i + 1 } if i != 0 && i == len1 { *(*uint8)(unsafe.Pointer(name + uintptr(i-uint64(1)))) = uint8(0) @@ -151617,7 +151617,7 @@ func Xnice(tls *TLS, inc int32) (r int32) { // Only query old priority if it can affect the result. // This also avoids issues with integer overflow. if inc > -Int32FromInt32(2)*Int32FromInt32(NZERO) && inc < Int32FromInt32(2)*Int32FromInt32(NZERO) { - prio += Xgetpriority(tls, PRIO_PROCESS, uint32(0)) + prio = prio + Xgetpriority(tls, PRIO_PROCESS, uint32(0)) } if prio > Int32FromInt32(NZERO)-Int32FromInt32(1) { prio = Int32FromInt32(NZERO) - Int32FromInt32(1) diff --git a/vendor/modernc.org/libc/libc_netbsd.go b/vendor/modernc.org/libc/libc_netbsd.go index 3bf0a2b..bd07ca1 100644 --- a/vendor/modernc.org/libc/libc_netbsd.go +++ b/vendor/modernc.org/libc/libc_netbsd.go @@ -1950,3 +1950,50 @@ func Xbswap64(t *TLS, x uint64) uint64 { } return X__builtin_bswap64(t, x) } + +// int nanosleep(const struct timespec *req, struct timespec *rem); +func Xnanosleep(t *TLS, req, rem uintptr) int32 { + if __ccgo_strace { + trc("t=%v rem=%v, (%v:)", t, rem, origin(2)) + } + v := *(*time.Timespec)(unsafe.Pointer(req)) + gotime.Sleep(gotime.Second*gotime.Duration(v.Ftv_sec) + gotime.Duration(v.Ftv_nsec)) + return 0 +} + +// ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset); +func Xpwrite(t *TLS, fd int32, buf uintptr, count types.Size_t, offset types.Off_t) types.Ssize_t { + if __ccgo_strace { + trc("t=%v fd=%v buf=%v count=%v offset=%v, (%v:)", t, fd, buf, count, offset, origin(2)) + } + var n int + var err error + switch { + case count == 0: + n, err = unix.Pwrite(int(fd), nil, int64(offset)) + default: + n, err = unix.Pwrite(int(fd), (*RawMem)(unsafe.Pointer(buf))[:count:count], int64(offset)) + // if dmesgs { + // dmesg("%v: fd %v, off %#x, count %#x\n%s", origin(1), fd, offset, count, hex.Dump((*RawMem)(unsafe.Pointer(buf))[:count:count])) + // } + } + if err != nil { + // if dmesgs { + // dmesg("%v: %v FAIL", origin(1), err) + // } + t.setErrno(err) + return -1 + } + + // if dmesgs { + // dmesg("%v: ok", origin(1)) + // } + return types.Ssize_t(n) +} + +func Xrewinddir(tls *TLS, f uintptr) { + if __ccgo_strace { + trc("tls=%v f=%v, (%v:)", tls, f, origin(2)) + } + Xfseek(tls, f, 0, stdio.SEEK_SET) +} diff --git a/vendor/modernc.org/libc/libc_netbsd_amd64.go b/vendor/modernc.org/libc/libc_netbsd_amd64.go index a353b93..98d5033 100644 --- a/vendor/modernc.org/libc/libc_netbsd_amd64.go +++ b/vendor/modernc.org/libc/libc_netbsd_amd64.go @@ -708,3 +708,23 @@ func Xopendir(t *TLS, name uintptr) uintptr { (*darwinDir)(unsafe.Pointer(p)).eof = false return p } + +func AtomicLoadPInt8(addr uintptr) (val int8) { + return int8(a_load_8(addr)) +} + +func AtomicLoadPInt16(addr uintptr) (val int16) { + return int16(a_load_16(addr)) +} + +func AtomicLoadPUint8(addr uintptr) byte { + return byte(a_load_8(addr)) +} + +func AtomicLoadPUint16(addr uintptr) uint16 { + return uint16(a_load_16(addr)) +} + +func AtomicLoadNUint8(ptr uintptr, memorder int32) uint8 { + return byte(a_load_8(ptr)) +} diff --git a/vendor/modernc.org/libc/libc_openbsd.go b/vendor/modernc.org/libc/libc_openbsd.go index 09e7a56..684a63c 100644 --- a/vendor/modernc.org/libc/libc_openbsd.go +++ b/vendor/modernc.org/libc/libc_openbsd.go @@ -2350,12 +2350,18 @@ func Xtime(t *TLS, tloc uintptr) time.Time_t { if __ccgo_strace { trc("t=%v tloc=%v, (%v:)", t, tloc, origin(2)) } - panic(todo("")) - // n := time.Now().UTC().Unix() - // if tloc != 0 { - // *(*types.Time_t)(unsafe.Pointer(tloc)) = types.Time_t(n) - // } - // return types.Time_t(n) + + var tvs unix.Timeval + err := unix.Gettimeofday(&tvs) + if err != nil { + t.setErrno(err) + return types.Time_t(-1) + } + + if tloc != 0 { + *(*types.Time_t)(unsafe.Pointer(tloc)) = types.Time_t(tvs.Sec) + } + return types.Time_t(tvs.Sec) } // int utimes(const char *filename, const struct timeval times[2]); diff --git a/vendor/modernc.org/libc/libc_windows.go b/vendor/modernc.org/libc/libc_windows.go index b5fb0a8..0e3f4f0 100644 --- a/vendor/modernc.org/libc/libc_windows.go +++ b/vendor/modernc.org/libc/libc_windows.go @@ -6032,7 +6032,10 @@ func Xputchar(t *TLS, c int32) int32 { if __ccgo_strace { trc("t=%v c=%v, (%v:)", t, c, origin(2)) } - panic(todo("")) + if _, err := fwrite(unistd.STDOUT_FILENO, []byte{byte(c)}); err != nil { + return -1 + } + return int32(byte(c)) } // void _assert( diff --git a/vendor/modernc.org/sqlite/AUTHORS b/vendor/modernc.org/sqlite/AUTHORS index 268498a..7b23676 100644 --- a/vendor/modernc.org/sqlite/AUTHORS +++ b/vendor/modernc.org/sqlite/AUTHORS @@ -29,3 +29,4 @@ Saed SayedAhmed Steffen Butzer Toni Spets W. Michael Petullo +SUSE LLC diff --git a/vendor/modernc.org/sqlite/CONTRIBUTORS b/vendor/modernc.org/sqlite/CONTRIBUTORS index 8c09cfc..e853421 100644 --- a/vendor/modernc.org/sqlite/CONTRIBUTORS +++ b/vendor/modernc.org/sqlite/CONTRIBUTORS @@ -41,3 +41,4 @@ W. Michael Petullo Walter Wanderley Yaacov Akiba Slama Prathyush PV +SUSE LLC diff --git a/vendor/modernc.org/sqlite/sqlite.go b/vendor/modernc.org/sqlite/sqlite.go index 01f2fec..01e6a03 100644 --- a/vendor/modernc.org/sqlite/sqlite.go +++ b/vendor/modernc.org/sqlite/sqlite.go @@ -648,6 +648,9 @@ func (s *stmt) query(ctx context.Context, args []driver.NamedValue) (r driver.Ro defer func() { if ctx != nil && atomic.LoadInt32(&done) != 0 { + if r != nil { + r.Close() + } r, err = nil, ctx.Err() } else if r == nil && err == nil { r, err = newRows(s.c, pstmt, allocs, true) diff --git a/vendor/modules.txt b/vendor/modules.txt index ac90a89..ae9fa64 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -24,6 +24,9 @@ github.com/buger/jsonparser # github.com/cention-sany/utf7 v0.0.0-20170124080048-26cad61bd60a ## explicit github.com/cention-sany/utf7 +# github.com/clipperhouse/displaywidth v0.6.1 +## explicit; go 1.18 +github.com/clipperhouse/displaywidth # github.com/clipperhouse/stringish v0.1.1 ## explicit; go 1.18 github.com/clipperhouse/stringish @@ -56,10 +59,10 @@ github.com/etkecc/go-fswatcher # github.com/etkecc/go-healthchecks/v2 v2.2.2 ## explicit; go 1.18 github.com/etkecc/go-healthchecks/v2 -# github.com/etkecc/go-kit v1.7.5 +# github.com/etkecc/go-kit v1.7.6 ## explicit; go 1.22 github.com/etkecc/go-kit -# github.com/etkecc/go-linkpearl v0.0.0-20251016112544-0d85fb3bccdc +# github.com/etkecc/go-linkpearl v0.0.0-20251209104933-55b9c56572bb ## explicit; go 1.24.0 github.com/etkecc/go-linkpearl # github.com/etkecc/go-mxidwc v1.0.1 @@ -90,8 +93,8 @@ github.com/gabriel-vasile/mimetype/internal/json github.com/gabriel-vasile/mimetype/internal/magic github.com/gabriel-vasile/mimetype/internal/markup github.com/gabriel-vasile/mimetype/internal/scan -# github.com/getsentry/sentry-go v0.36.2 -## explicit; go 1.23 +# github.com/getsentry/sentry-go v0.40.0 +## explicit; go 1.23.0 github.com/getsentry/sentry-go github.com/getsentry/sentry-go/attribute github.com/getsentry/sentry-go/internal/debug @@ -101,6 +104,7 @@ github.com/getsentry/sentry-go/internal/otel/baggage github.com/getsentry/sentry-go/internal/otel/baggage/internal/baggage github.com/getsentry/sentry-go/internal/protocol github.com/getsentry/sentry-go/internal/ratelimit +github.com/getsentry/sentry-go/internal/telemetry # github.com/go-openapi/jsonpointer v0.19.5 ## explicit; go 1.13 github.com/go-openapi/jsonpointer @@ -177,19 +181,20 @@ github.com/olekukonko/cat # github.com/olekukonko/errors v1.1.0 ## explicit; go 1.21 github.com/olekukonko/errors -# github.com/olekukonko/ll v0.1.2 +# github.com/olekukonko/ll v0.1.3 ## explicit; go 1.21 github.com/olekukonko/ll github.com/olekukonko/ll/lh github.com/olekukonko/ll/lx -# github.com/olekukonko/tablewriter v1.1.0 +# github.com/olekukonko/tablewriter v1.1.2 ## explicit; go 1.21 github.com/olekukonko/tablewriter +github.com/olekukonko/tablewriter/pkg/twcache github.com/olekukonko/tablewriter/pkg/twwarp github.com/olekukonko/tablewriter/pkg/twwidth github.com/olekukonko/tablewriter/renderer github.com/olekukonko/tablewriter/tw -# github.com/petermattis/goid v0.0.0-20250904145737-900bdf8bb490 +# github.com/petermattis/goid v0.0.0-20251121121749-a11dd1a45f9a ## explicit; go 1.17 github.com/petermattis/goid # github.com/pkg/errors v0.9.1 @@ -201,9 +206,6 @@ github.com/raja/argon2pw # github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec ## explicit; go 1.12 github.com/remyoudompheng/bigfft -# github.com/rivo/uniseg v0.4.7 -## explicit; go 1.18 -github.com/rivo/uniseg # github.com/rs/zerolog v1.34.0 ## explicit; go 1.15 github.com/rs/zerolog @@ -239,7 +241,7 @@ github.com/yuin/goldmark/renderer github.com/yuin/goldmark/renderer/html github.com/yuin/goldmark/text github.com/yuin/goldmark/util -# go.mau.fi/util v0.9.2 +# go.mau.fi/util v0.9.3 ## explicit; go 1.24.0 go.mau.fi/util/base58 go.mau.fi/util/confusable @@ -260,7 +262,7 @@ go.mau.fi/util/jsontime go.mau.fi/util/ptr go.mau.fi/util/random go.mau.fi/util/retryafter -# golang.org/x/crypto v0.43.0 +# golang.org/x/crypto v0.46.0 ## explicit; go 1.24.0 golang.org/x/crypto/argon2 golang.org/x/crypto/blake2b @@ -274,12 +276,12 @@ golang.org/x/crypto/internal/poly1305 golang.org/x/crypto/pbkdf2 golang.org/x/crypto/ssh golang.org/x/crypto/ssh/internal/bcrypt_pbkdf -# golang.org/x/exp v0.0.0-20251023183803-a4bb9ffd2546 +# golang.org/x/exp v0.0.0-20251125195548-87e1e737ad39 ## explicit; go 1.24.0 golang.org/x/exp/constraints golang.org/x/exp/maps golang.org/x/exp/slices -# golang.org/x/net v0.46.0 +# golang.org/x/net v0.48.0 ## explicit; go 1.24.0 golang.org/x/net/html golang.org/x/net/html/atom @@ -289,13 +291,13 @@ golang.org/x/net/http2/hpack golang.org/x/net/idna golang.org/x/net/internal/httpcommon golang.org/x/net/publicsuffix -# golang.org/x/sys v0.37.0 +# golang.org/x/sys v0.39.0 ## explicit; go 1.24.0 golang.org/x/sys/cpu golang.org/x/sys/execabs golang.org/x/sys/unix golang.org/x/sys/windows -# golang.org/x/text v0.30.0 +# golang.org/x/text v0.32.0 ## explicit; go 1.24.0 golang.org/x/text/cases golang.org/x/text/encoding @@ -319,7 +321,7 @@ golang.org/x/text/transform golang.org/x/text/unicode/bidi golang.org/x/text/unicode/norm golang.org/x/text/width -# golang.org/x/tools v0.38.0 +# golang.org/x/tools v0.39.0 ## explicit; go 1.24.0 golang.org/x/tools/go/ast/astutil golang.org/x/tools/go/buildutil @@ -328,7 +330,7 @@ golang.org/x/tools/go/loader # gopkg.in/yaml.v2 v2.4.0 ## explicit; go 1.15 gopkg.in/yaml.v2 -# maunium.net/go/mautrix v0.25.2 +# maunium.net/go/mautrix v0.26.0 ## explicit; go 1.24.0 maunium.net/go/mautrix maunium.net/go/mautrix/crypto @@ -362,8 +364,8 @@ maunium.net/go/mautrix/format/mdext maunium.net/go/mautrix/id maunium.net/go/mautrix/pushrules maunium.net/go/mautrix/sqlstatestore -# modernc.org/libc v1.66.10 -## explicit; go 1.23.0 +# modernc.org/libc v1.67.1 +## explicit; go 1.24.0 modernc.org/libc modernc.org/libc/errno modernc.org/libc/fcntl @@ -396,7 +398,7 @@ modernc.org/mathutil # modernc.org/memory v1.11.0 ## explicit; go 1.23.0 modernc.org/memory -# modernc.org/sqlite v1.40.0 +# modernc.org/sqlite v1.40.1 ## explicit; go 1.24.0 modernc.org/sqlite modernc.org/sqlite/lib