Upstep Go dependencies (#340)

* Upstep Go dependencies

* tiny linter fix

* Tidy

1 files changed, 1214 insertions, 1214 deletions

diff --git a/vendor/modernc.org/libc/musl_linux_amd64.go b/vendor/modernc.org/libc/musl_linux_amd64.go
index 9b2efafc9..874dfbdf8 100644
--- a/vendor/modernc.org/libc/musl_linux_amd64.go
+++ b/vendor/modernc.org/libc/musl_linux_amd64.go
@@ -370,7 +370,7 @@ type uint32_t = uint32 /* alltypes.h:131:25 */
 type uint64_t = uint64 /* alltypes.h:136:25 */
 
 func __bswap32(tls *TLS, __x uint32_t) uint32_t { /* endian.h:24:26: */
-	return ((((__x >> 24) | ((__x >> 8) & uint32_t(0xff00))) | ((__x << 8) & uint32_t(0xff0000))) | (__x << 24))
+	return __x>>24 | __x>>8&uint32_t(0xff00) | __x<<8&uint32_t(0xff0000) | __x<<24
 }
 
 var table = [384]uint16{
@@ -378,22 +378,22 @@ var table = [384]uint16{
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
-	(uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)),
-	(uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x320) / 256) | ((0x320) * 256)) % 65536)), (uint16((((0x220) / 256) | ((0x220) * 256)) % 65536)), (uint16((((0x220) / 256) | ((0x220) * 256)) % 65536)), (uint16((((0x220) / 256) | ((0x220) * 256)) % 65536)), (uint16((((0x220) / 256) | ((0x220) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)),
-	(uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)),
-	(uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)),
-	(uint16((((0x160) / 256) | ((0x160) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)),
-	(uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)),
-	(uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)),
-	(uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x8d8) / 256) | ((0x8d8) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)),
-	(uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8d5) / 256) | ((0x8d5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)),
-	(uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)),
-	(uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)),
-	(uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x8c5) / 256) | ((0x8c5) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)),
-	(uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8d6) / 256) | ((0x8d6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)),
-	(uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)),
-	(uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)),
-	(uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x8c6) / 256) | ((0x8c6) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x4c0) / 256) | ((0x4c0) * 256)) % 65536)), (uint16((((0x200) / 256) | ((0x200) * 256)) % 65536)),
+	uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536),
+	uint16((0x200/256 | 0x200*256) % 65536), uint16((0x320/256 | 0x320*256) % 65536), uint16((0x220/256 | 0x220*256) % 65536), uint16((0x220/256 | 0x220*256) % 65536), uint16((0x220/256 | 0x220*256) % 65536), uint16((0x220/256 | 0x220*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536),
+	uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536),
+	uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536),
+	uint16((0x160/256 | 0x160*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536),
+	uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536),
+	uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536),
+	uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x8d8/256 | 0x8d8*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536),
+	uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8d5/256 | 0x8d5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536),
+	uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536),
+	uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536),
+	uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x8c5/256 | 0x8c5*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536),
+	uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8d6/256 | 0x8d6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536),
+	uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536),
+	uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536),
+	uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x8c6/256 | 0x8c6*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x4c0/256 | 0x4c0*256) % 65536), uint16((0x200/256 | 0x200*256) % 65536),
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
 	uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0), uint16(0),
@@ -407,7 +407,7 @@ func X__ctype_b_loc(tls *TLS) uintptr { /* __ctype_b_loc.c:38:22: */
 }
 
 func __isspace(tls *TLS, _c int32) int32 { /* ctype.h:26:21: */
-	return (Bool32((_c == ' ') || ((uint32(_c) - uint32('\t')) < uint32(5))))
+	return Bool32(_c == ' ' || uint32(_c)-uint32('\t') < uint32(5))
 }
 
 type __locale_struct = struct{ cat [6]uintptr } /* alltypes.h:343:9 */
@@ -415,17 +415,17 @@ type __locale_struct = struct{ cat [6]uintptr } /* alltypes.h:343:9 */
 type locale_t = uintptr /* alltypes.h:343:32 */
 
 func Xisalnum(tls *TLS, c int32) int32 { /* isalnum.c:3:5: */
-	return (Bool32((func() int32 {
+	return Bool32(func() int32 {
 		if 0 != 0 {
 			return Xisalpha(tls, c)
 		}
-		return (Bool32((((uint32(c)) | uint32(32)) - uint32('a')) < uint32(26)))
-	}() != 0) || (func() int32 {
+		return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
+	}() != 0 || func() int32 {
 		if 0 != 0 {
 			return Xisdigit(tls, c)
 		}
-		return (Bool32(((uint32(c)) - uint32('0')) < uint32(10)))
-	}() != 0)))
+		return Bool32(uint32(c)-uint32('0') < uint32(10))
+	}() != 0)
 }
 
 func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 { /* isalnum.c:8:5: */
@@ -433,7 +433,7 @@ func X__isalnum_l(tls *TLS, c int32, l locale_t) int32 { /* isalnum.c:8:5: */
 }
 
 func Xisalpha(tls *TLS, c int32) int32 { /* isalpha.c:4:5: */
-	return (Bool32(((uint32(c) | uint32(32)) - uint32('a')) < uint32(26)))
+	return Bool32(uint32(c)|uint32(32)-uint32('a') < uint32(26))
 }
 
 func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 { /* isalpha.c:9:5: */
@@ -441,7 +441,7 @@ func X__isalpha_l(tls *TLS, c int32, l locale_t) int32 { /* isalpha.c:9:5: */
 }
 
 func Xisdigit(tls *TLS, c int32) int32 { /* isdigit.c:4:5: */
-	return (Bool32((uint32(c) - uint32('0')) < uint32(10)))
+	return Bool32(uint32(c)-uint32('0') < uint32(10))
 }
 
 func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isdigit.c:9:5: */
@@ -449,7 +449,7 @@ func X__isdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isdigit.c:9:5: */
 }
 
 func Xislower(tls *TLS, c int32) int32 { /* islower.c:4:5: */
-	return (Bool32((uint32(c) - uint32('a')) < uint32(26)))
+	return Bool32(uint32(c)-uint32('a') < uint32(26))
 }
 
 func X__islower_l(tls *TLS, c int32, l locale_t) int32 { /* islower.c:9:5: */
@@ -457,7 +457,7 @@ func X__islower_l(tls *TLS, c int32, l locale_t) int32 { /* islower.c:9:5: */
 }
 
 func Xisprint(tls *TLS, c int32) int32 { /* isprint.c:4:5: */
-	return (Bool32((uint32(c) - uint32(0x20)) < uint32(0x5f)))
+	return Bool32(uint32(c)-uint32(0x20) < uint32(0x5f))
 }
 
 func X__isprint_l(tls *TLS, c int32, l locale_t) int32 { /* isprint.c:9:5: */
@@ -465,7 +465,7 @@ func X__isprint_l(tls *TLS, c int32, l locale_t) int32 { /* isprint.c:9:5: */
 }
 
 func Xisupper(tls *TLS, c int32) int32 { /* isupper.c:4:5: */
-	return (Bool32((uint32(c) - uint32('A')) < uint32(26)))
+	return Bool32(uint32(c)-uint32('A') < uint32(26))
 }
 
 func X__isupper_l(tls *TLS, c int32, l locale_t) int32 { /* isupper.c:9:5: */
@@ -473,12 +473,12 @@ func X__isupper_l(tls *TLS, c int32, l locale_t) int32 { /* isupper.c:9:5: */
 }
 
 func Xisxdigit(tls *TLS, c int32) int32 { /* isxdigit.c:3:5: */
-	return (Bool32((func() int32 {
+	return Bool32(func() int32 {
 		if 0 != 0 {
 			return Xisdigit(tls, c)
 		}
-		return (Bool32(((uint32(c)) - uint32('0')) < uint32(10)))
-	}() != 0) || (((uint32(c) | uint32(32)) - uint32('a')) < uint32(6))))
+		return Bool32(uint32(c)-uint32('0') < uint32(10))
+	}() != 0 || uint32(c)|uint32(32)-uint32('a') < uint32(6))
 }
 
 func X__isxdigit_l(tls *TLS, c int32, l locale_t) int32 { /* isxdigit.c:8:5: */
@@ -574,7 +574,7 @@ func Xopendir(tls *TLS, name uintptr) uintptr { /* opendir.c:8:5: */
 	var fd int32
 	var dir uintptr
 
-	if (AssignInt32(&fd, Xopen(tls, name, ((00|0200000)|02000000), 0))) < 0 {
+	if AssignInt32(&fd, Xopen(tls, name, 00|0200000|02000000, 0)) < 0 {
 		return uintptr(0)
 	}
 	if !(int32(AssignUintptr(&dir, Xcalloc(tls, uint64(1), uint64(unsafe.Sizeof(DIR{}))))) != 0) {
@@ -596,18 +596,18 @@ func Xreaddir(tls *TLS, dir uintptr) uintptr { /* readdir.c:10:15: */
 	var de uintptr
 
 	if (*DIR)(unsafe.Pointer(dir)).buf_pos >= (*DIR)(unsafe.Pointer(dir)).buf_end {
-		var len int32 = int32(X__syscall3(tls, int64(217), int64((*DIR)(unsafe.Pointer(dir)).fd), int64(dir+24 /* &.buf */), int64(unsafe.Sizeof([2048]int8{}))))
+		var len int32 = int32(X__syscall3(tls, int64(217), int64((*DIR)(unsafe.Pointer(dir)).fd), int64(dir+24), int64(unsafe.Sizeof([2048]int8{}))))
 		if len <= 0 {
-			if (len < 0) && (len != -2) {
-				(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = -len
+			if len < 0 && len != -2 {
+				*(*int32)(unsafe.Pointer(X___errno_location(tls))) = -len
 			}
 			return uintptr(0)
 		}
 		(*DIR)(unsafe.Pointer(dir)).buf_end = len
 		(*DIR)(unsafe.Pointer(dir)).buf_pos = 0
 	}
-	de = ((dir + 24 /* &.buf */) + uintptr((*DIR)(unsafe.Pointer(dir)).buf_pos))
-	*(*int32)(unsafe.Pointer(dir + 12 /* &.buf_pos */)) += (int32((*dirent)(unsafe.Pointer(de)).d_reclen))
+	de = dir + 24 + uintptr((*DIR)(unsafe.Pointer(dir)).buf_pos)
+	*(*int32)(unsafe.Pointer(dir + 12)) += int32((*dirent)(unsafe.Pointer(de)).d_reclen)
 	(*DIR)(unsafe.Pointer(dir)).tell = (*dirent)(unsafe.Pointer(de)).d_off
 	return de
 }
@@ -706,8 +706,8 @@ func __FLOAT_BITS(tls *TLS, __f float32) uint32 { /* math.h:55:26: */
 
 	// var __u struct {__f float32;} at bp, 4
 
-	*(*float32)(unsafe.Pointer(bp /* &__u */)) = __f
-	return *(*uint32)(unsafe.Pointer(bp /* &__u */))
+	*(*float32)(unsafe.Pointer(bp)) = __f
+	return *(*uint32)(unsafe.Pointer(bp))
 }
 
 func __DOUBLE_BITS(tls *TLS, __f float64) uint64 { /* math.h:61:36: */
@@ -716,8 +716,8 @@ func __DOUBLE_BITS(tls *TLS, __f float64) uint64 { /* math.h:61:36: */
 
 	// var __u struct {__f float64;} at bp, 8
 
-	*(*float64)(unsafe.Pointer(bp /* &__u */)) = __f
-	return *(*uint64)(unsafe.Pointer(bp /* &__u */))
+	*(*float64)(unsafe.Pointer(bp)) = __f
+	return *(*uint64)(unsafe.Pointer(bp))
 }
 
 type __pthread = struct {
@@ -767,57 +767,57 @@ func scanexp(tls *TLS, f uintptr, pok int32) int64 { /* floatscan.c:37:18: */
 	var neg int32 = 0
 
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}()
-	if (c == '+') || (c == '-') {
-		neg = (Bool32(c == '-'))
+	if c == '+' || c == '-' {
+		neg = Bool32(c == '-')
 		c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
 		}()
-		if ((uint32(c - '0')) >= 10) && (pok != 0) {
-			if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if uint32(c-'0') >= 10 && pok != 0 {
+			if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 				(*FILE)(unsafe.Pointer(f)).rpos--
 			} else {
 			}
 		}
 	}
-	if (uint32(c - '0')) >= 10 {
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if uint32(c-'0') >= 10 {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
-		return (-0x7fffffffffffffff - int64(1))
+		return -0x7fffffffffffffff - int64(1)
 	}
-	for x = 0; ((uint32(c - '0')) < 10) && (x < (0x7fffffff / 10)); c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	for x = 0; uint32(c-'0') < 10 && x < 0x7fffffff/10; c = func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}() {
-		x = (((10 * x) + c) - '0')
+		x = 10*x + c - '0'
 	}
-	for y = int64(x); ((uint32(c - '0')) < 10) && (y < (0x7fffffffffffffff / int64(100))); c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	for y = int64(x); uint32(c-'0') < 10 && y < 0x7fffffffffffffff/int64(100); c = func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}() {
-		y = (((int64(10) * y) + int64(c)) - int64('0'))
+		y = int64(10)*y + int64(c) - int64('0')
 	}
-	for ; (uint32(c - '0')) < 10; c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	for ; uint32(c-'0') < 10; c = func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}() {
 	}
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
@@ -846,7 +846,7 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 	var gotrad int32 = 0
 	var rp int32
 	var e2 int32
-	var emax int32 = ((-emin - bits) + 3)
+	var emax int32 = -emin - bits + 3
 	var denormal int32 = 0
 	var y float64
 	var frac float64 = float64(0)
@@ -857,7 +857,7 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 
 	// Don't let leading zeros consume buffer space
 	for ; c == '0'; c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -867,12 +867,12 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 	if c == '.' {
 		gotrad = 1
 		for c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
 		}(); c == '0'; c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
@@ -882,9 +882,9 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 		}
 	}
 
-	*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */)) = uint32_t(0)
-	for ; ((uint32(c - '0')) < 10) || (c == '.'); c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	*(*uint32_t)(unsafe.Pointer(bp)) = uint32_t(0)
+	for ; uint32(c-'0') < 10 || c == '.'; c = func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -895,15 +895,15 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 			}
 			gotrad = 1
 			lrp = dc
-		} else if k < (128 - 3) {
+		} else if k < 128-3 {
 			dc++
 			if c != '0' {
 				lnz = int32(dc)
 			}
 			if j != 0 {
-				*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = (((*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) * uint32_t(10)) + uint32_t(c)) - uint32_t('0'))
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))*uint32_t(10) + uint32_t(c) - uint32_t('0')
 			} else {
-				*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = (uint32_t(c - '0'))
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = uint32_t(c - '0')
 			}
 			if PreIncInt32(&j, 1) == 9 {
 				k++
@@ -913,8 +913,8 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 		} else {
 			dc++
 			if c != '0' {
-				lnz = ((128 - 4) * 9)
-				*(*uint32_t)(unsafe.Pointer(bp /* &x */ + 124*4)) |= (uint32_t(1))
+				lnz = (128 - 4) * 9
+				*(*uint32_t)(unsafe.Pointer(bp + 124*4)) |= uint32_t(1)
 			}
 		}
 	}
@@ -922,11 +922,11 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 		lrp = dc
 	}
 
-	if (gotdig != 0) && ((c | 32) == 'e') {
+	if gotdig != 0 && c|32 == 'e' {
 		e10 = scanexp(tls, f, pok)
-		if e10 == (-0x7fffffffffffffff - int64(1)) {
+		if e10 == -0x7fffffffffffffff-int64(1) {
 			if pok != 0 {
-				if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+				if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 					(*FILE)(unsafe.Pointer(f)).rpos--
 				} else {
 				}
@@ -936,41 +936,41 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 			}
 			e10 = int64(0)
 		}
-		lrp = lrp + (e10)
+		lrp = lrp + e10
 	} else if c >= 0 {
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
 	}
 	if !(gotdig != 0) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 		X__shlim(tls, f, int64(0))
 		return float64(0)
 	}
 
 	// Handle zero specially to avoid nasty special cases later
-	if !(int32(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */))) != 0) {
-		return (float64(sign) * 0.0)
+	if !(int32(*(*uint32_t)(unsafe.Pointer(bp))) != 0) {
+		return float64(sign) * 0.0
 	}
 
 	// Optimize small integers (w/no exponent) and over/under-flow
-	if ((lrp == dc) && (dc < int64(10))) && ((bits > 30) || ((*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */)) >> bits) == uint32_t(0))) {
-		return (float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */))))
+	if lrp == dc && dc < int64(10) && (bits > 30 || *(*uint32_t)(unsafe.Pointer(bp))>>bits == uint32_t(0)) {
+		return float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp)))
 	}
-	if lrp > (int64(-emin / 2)) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
-		return ((float64(sign) * 1.79769313486231570815e+308) * 1.79769313486231570815e+308)
+	if lrp > int64(-emin/2) {
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
+		return float64(sign) * 1.79769313486231570815e+308 * 1.79769313486231570815e+308
 	}
-	if lrp < (int64(emin - (2 * 53))) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
-		return ((float64(sign) * 2.22507385850720138309e-308) * 2.22507385850720138309e-308)
+	if lrp < int64(emin-2*53) {
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
+		return float64(sign) * 2.22507385850720138309e-308 * 2.22507385850720138309e-308
 	}
 
 	// Align incomplete final B1B digit
 	if j != 0 {
 		for ; j < 9; j++ {
-			*(*uint32_t)(unsafe.Pointer(bp /* &x */ + uintptr(k)*4)) *= (uint32_t(10))
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) *= uint32_t(10)
 		}
 		k++
 		j = 0
@@ -982,62 +982,62 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 	rp = int32(lrp)
 
 	// Optimize small to mid-size integers (even in exp. notation)
-	if ((lnz < 9) && (lnz <= rp)) && (rp < 18) {
+	if lnz < 9 && lnz <= rp && rp < 18 {
 		if rp == 9 {
-			return (float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */))))
+			return float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp)))
 		}
 		if rp < 9 {
-			return ((float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */)))) / float64(_sp10s[(8-rp)]))
+			return float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp))) / float64(_sp10s[8-rp])
 		}
-		var bitlim int32 = (bits - (3 * (rp - 9)))
-		if (bitlim > 30) || ((*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */)) >> bitlim) == uint32_t(0)) {
-			return ((float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */)))) * float64(_sp10s[(rp-10)]))
+		var bitlim int32 = bits - 3*(rp-9)
+		if bitlim > 30 || *(*uint32_t)(unsafe.Pointer(bp))>>bitlim == uint32_t(0) {
+			return float64(sign) * float64(*(*uint32_t)(unsafe.Pointer(bp))) * float64(_sp10s[rp-10])
 		}
 	}
 
 	// Drop trailing zeros
-	for ; !(int32(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr((z-1))*4))) != 0); z-- {
+	for ; !(int32(*(*uint32_t)(unsafe.Pointer(bp + uintptr(z-1)*4))) != 0); z-- {
 	}
 
 	// Align radix point to B1B digit boundary
-	if (rp % 9) != 0 {
+	if rp%9 != 0 {
 		var rpm9 int32
 		if rp >= 0 {
-			rpm9 = (rp % 9)
+			rpm9 = rp % 9
 		} else {
-			rpm9 = ((rp % 9) + 9)
+			rpm9 = rp%9 + 9
 		}
-		var p10 int32 = _sp10s[(8 - rpm9)]
+		var p10 int32 = _sp10s[8-rpm9]
 		var carry uint32_t = uint32_t(0)
 		for k = a; k != z; k++ {
-			var tmp uint32_t = (*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) % uint32_t(p10))
-			*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = ((*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) / uint32_t(p10)) + carry)
-			carry = ((uint32_t(1000000000 / p10)) * tmp)
-			if (k == a) && !(int32(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4))) != 0) {
-				a = ((a + 1) & (128 - 1))
-				rp = rp - (9)
+			var tmp uint32_t = *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) % uint32_t(p10)
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))/uint32_t(p10) + carry
+			carry = uint32_t(1000000000/p10) * tmp
+			if k == a && !(int32(*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))) != 0) {
+				a = (a + 1) & (128 - 1)
+				rp = rp - 9
 			}
 		}
 		if carry != 0 {
-			*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(PostIncInt32(&z, 1))*4)) = carry
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(PostIncInt32(&z, 1))*4)) = carry
 		}
 		rp = rp + (9 - rpm9)
 	}
 
 	// Upscale until desired number of bits are left of radix point
-	for (rp < (9 * 2)) || ((rp == (9 * 2)) && (*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(a)*4)) < _sth[0])) {
+	for rp < 9*2 || rp == 9*2 && *(*uint32_t)(unsafe.Pointer(bp + uintptr(a)*4)) < _sth[0] {
 		var carry uint32_t = uint32_t(0)
-		e2 = e2 - (29)
-		for k = ((z - 1) & (128 - 1)); ; k = ((k - 1) & (128 - 1)) {
-			var tmp uint64_t = ((uint64_t(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4))) << 29) + uint64_t(carry))
+		e2 = e2 - 29
+		for k = (z - 1) & (128 - 1); ; k = (k - 1) & (128 - 1) {
+			var tmp uint64_t = uint64_t(*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)))<<29 + uint64_t(carry)
 			if tmp > uint64(1000000000) {
-				carry = (uint32_t(tmp / uint64(1000000000)))
-				*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = (uint32_t(tmp % uint64(1000000000)))
+				carry = uint32_t(tmp / uint64(1000000000))
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = uint32_t(tmp % uint64(1000000000))
 			} else {
 				carry = uint32_t(0)
-				*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = uint32_t(tmp)
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = uint32_t(tmp)
 			}
-			if ((k == ((z - 1) & (128 - 1))) && (k != a)) && !(int32(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4))) != 0) {
+			if k == (z-1)&(128-1) && k != a && !(int32(*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))) != 0) {
 				z = k
 			}
 			if k == a {
@@ -1045,13 +1045,13 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 			}
 		}
 		if carry != 0 {
-			rp = rp + (9)
-			a = ((a - 1) & (128 - 1))
+			rp = rp + 9
+			a = (a - 1) & (128 - 1)
 			if a == z {
-				z = ((z - 1) & (128 - 1))
-				*(*uint32_t)(unsafe.Pointer(bp /* &x */ + uintptr(((z-1)&(128-1)))*4)) |= (*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(z)*4)))
+				z = (z - 1) & (128 - 1)
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr((z-1)&(128-1))*4)) |= *(*uint32_t)(unsafe.Pointer(bp + uintptr(z)*4))
 			}
-			*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(a)*4)) = carry
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(a)*4)) = carry
 		}
 	}
 
@@ -1060,56 +1060,56 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 		var carry uint32_t = uint32_t(0)
 		var sh int32 = 1
 		for i = 0; i < 2; i++ {
-			k = ((a + i) & (128 - 1))
-			if (k == z) || (*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) < _sth[i]) {
+			k = (a + i) & (128 - 1)
+			if k == z || *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) < _sth[i] {
 				i = 2
 				break
 			}
-			if *(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(((a+i)&(128-1)))*4)) > _sth[i] {
+			if *(*uint32_t)(unsafe.Pointer(bp + uintptr((a+i)&(128-1))*4)) > _sth[i] {
 				break
 			}
 		}
-		if (i == 2) && (rp == (9 * 2)) {
+		if i == 2 && rp == 9*2 {
 			break
 		}
 		// FIXME: find a way to compute optimal sh
-		if rp > (9 + (9 * 2)) {
+		if rp > 9+9*2 {
 			sh = 9
 		}
-		e2 = e2 + (sh)
-		for k = a; k != z; k = ((k + 1) & (128 - 1)) {
-			var tmp uint32_t = (*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) & (uint32_t((int32(1) << sh) - 1)))
-			*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) = ((*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4)) >> sh) + carry)
-			carry = ((uint32_t(int32(1000000000) >> sh)) * tmp)
-			if (k == a) && !(int32(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(k)*4))) != 0) {
-				a = ((a + 1) & (128 - 1))
+		e2 = e2 + sh
+		for k = a; k != z; k = (k + 1) & (128 - 1) {
+			var tmp uint32_t = *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) & uint32_t(int32(1)<<sh-1)
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4)) = *(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))>>sh + carry
+			carry = uint32_t(int32(1000000000)>>sh) * tmp
+			if k == a && !(int32(*(*uint32_t)(unsafe.Pointer(bp + uintptr(k)*4))) != 0) {
+				a = (a + 1) & (128 - 1)
 				i--
-				rp = rp - (9)
+				rp = rp - 9
 			}
 		}
 		if carry != 0 {
-			if ((z + 1) & (128 - 1)) != a {
-				*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(z)*4)) = carry
-				z = ((z + 1) & (128 - 1))
+			if (z+1)&(128-1) != a {
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr(z)*4)) = carry
+				z = (z + 1) & (128 - 1)
 			} else {
-				*(*uint32_t)(unsafe.Pointer(bp /* &x */ + uintptr(((z-1)&(128-1)))*4)) |= (uint32_t(1))
+				*(*uint32_t)(unsafe.Pointer(bp + uintptr((z-1)&(128-1))*4)) |= uint32_t(1)
 			}
 		}
 	}
 
 	// Assemble desired bits into floating point variable
 	for y = float64(AssignInt32(&i, 0)); i < 2; i++ {
-		if ((a + i) & (128 - 1)) == z {
-			*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(((AssignInt32(&z, ((z+1)&(128-1))))-1))*4)) = uint32_t(0)
+		if (a+i)&(128-1) == z {
+			*(*uint32_t)(unsafe.Pointer(bp + uintptr(AssignInt32(&z, (z+1)&(128-1))-1)*4)) = uint32_t(0)
 		}
-		y = ((1000000000.0 * y) + float64(*(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(((a+i)&(128-1)))*4))))
+		y = 1000000000.0*y + float64(*(*uint32_t)(unsafe.Pointer(bp + uintptr((a+i)&(128-1))*4)))
 	}
 
-	y = y * (float64(sign))
+	y = y * float64(sign)
 
 	// Limit precision for denormal results
-	if bits > ((53 + e2) - emin) {
-		bits = ((53 + e2) - emin)
+	if bits > 53+e2-emin {
+		bits = 53 + e2 - emin
 		if bits < 0 {
 			bits = 0
 		}
@@ -1118,44 +1118,44 @@ func decfloat(tls *TLS, f uintptr, c int32, bits int32, emin int32, sign int32,
 
 	// Calculate bias term to force rounding, move out lower bits
 	if bits < 53 {
-		bias = Xcopysignl(tls, Xscalbn(tls, float64(1), (((2*53)-bits)-1)), y)
-		frac = Xfmodl(tls, y, Xscalbn(tls, float64(1), (53-bits)))
-		y = y - (frac)
-		y = y + (bias)
+		bias = Xcopysignl(tls, Xscalbn(tls, float64(1), 2*53-bits-1), y)
+		frac = Xfmodl(tls, y, Xscalbn(tls, float64(1), 53-bits))
+		y = y - frac
+		y = y + bias
 	}
 
 	// Process tail of decimal input so it can affect rounding
-	if ((a + i) & (128 - 1)) != z {
-		var t uint32_t = *(*uint32_t)(unsafe.Pointer(bp /* &x[0] */ + uintptr(((a+i)&(128-1)))*4))
-		if (t < uint32_t(500000000)) && ((t != 0) || ((((a + i) + 1) & (128 - 1)) != z)) {
-			frac = frac + (0.25 * float64(sign))
+	if (a+i)&(128-1) != z {
+		var t uint32_t = *(*uint32_t)(unsafe.Pointer(bp + uintptr((a+i)&(128-1))*4))
+		if t < uint32_t(500000000) && (t != 0 || (a+i+1)&(128-1) != z) {
+			frac = frac + 0.25*float64(sign)
 		} else if t > uint32_t(500000000) {
-			frac = frac + (0.75 * float64(sign))
+			frac = frac + 0.75*float64(sign)
 		} else if t == uint32_t(500000000) {
-			if (((a + i) + 1) & (128 - 1)) == z {
-				frac = frac + (0.5 * float64(sign))
+			if (a+i+1)&(128-1) == z {
+				frac = frac + 0.5*float64(sign)
 			} else {
-				frac = frac + (0.75 * float64(sign))
+				frac = frac + 0.75*float64(sign)
 			}
 		}
-		if ((53 - bits) >= 2) && !(Xfmodl(tls, frac, float64(1)) != 0) {
+		if 53-bits >= 2 && !(Xfmodl(tls, frac, float64(1)) != 0) {
 			frac += 1
 		}
 	}
 
-	y = y + (frac)
-	y = y - (bias)
+	y = y + frac
+	y = y - bias
 
-	if ((e2 + 53) & 0x7fffffff) > (emax - 5) {
-		if Xfabsl(tls, y) >= (float64(float64(2)) / 2.22044604925031308085e-16) {
-			if (denormal != 0) && (bits == ((53 + e2) - emin)) {
+	if (e2+53)&0x7fffffff > emax-5 {
+		if Xfabsl(tls, y) >= float64(float64(2))/2.22044604925031308085e-16 {
+			if denormal != 0 && bits == 53+e2-emin {
 				denormal = 0
 			}
-			y = y * (0.5)
+			y = y * 0.5
 			e2++
 		}
-		if ((e2 + 53) > emax) || ((denormal != 0) && (frac != 0)) {
-			(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
+		if e2+53 > emax || denormal != 0 && frac != 0 {
+			*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
 		}
 	}
 
@@ -1181,7 +1181,7 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 	var c int32
 
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1189,7 +1189,7 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 
 	// Skip leading zeros
 	for ; c == '0'; c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1200,7 +1200,7 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 	if c == '.' {
 		gotrad = 1
 		c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
@@ -1215,7 +1215,7 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 		goto __2
 	__2:
 		c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
@@ -1226,8 +1226,8 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 	__3:
 	}
 
-	for ; (((uint32(c - '0')) < 10) || ((uint32((c | 32) - 'a')) < 6)) || (c == '.'); c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	for ; uint32(c-'0') < 10 || uint32(c|32-'a') < 6 || c == '.'; c = func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1241,33 +1241,33 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 		} else {
 			gotdig = 1
 			if c > '9' {
-				d = (((c | 32) + 10) - 'a')
+				d = c | 32 + 10 - 'a'
 			} else {
-				d = (c - '0')
+				d = c - '0'
 			}
 			if dc < int64(8) {
-				x = ((x * uint32_t(16)) + uint32_t(d))
-			} else if dc < (int64((53 / 4) + 1)) {
-				y = y + (float64(d) * (AssignDivFloat64(&scale, float64(16))))
-			} else if (d != 0) && !(gottail != 0) {
-				y = y + (0.5 * scale)
+				x = x*uint32_t(16) + uint32_t(d)
+			} else if dc < int64(53/4+1) {
+				y = y + float64(d)*AssignDivFloat64(&scale, float64(16))
+			} else if d != 0 && !(gottail != 0) {
+				y = y + 0.5*scale
 				gottail = 1
 			}
 			dc++
 		}
 	}
 	if !(gotdig != 0) {
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
 		if pok != 0 {
-			if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+			if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 				(*FILE)(unsafe.Pointer(f)).rpos--
 			} else {
 			}
 			if gotrad != 0 {
-				if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+				if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 					(*FILE)(unsafe.Pointer(f)).rpos--
 				} else {
 				}
@@ -1275,20 +1275,20 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 		} else {
 			X__shlim(tls, f, int64(0))
 		}
-		return (float64(sign) * 0.0)
+		return float64(sign) * 0.0
 	}
 	if !(gotrad != 0) {
 		rp = dc
 	}
 	for dc < int64(8) {
-		x = x * (uint32_t(16))
+		x = x * uint32_t(16)
 		dc++
 	}
-	if (c | 32) == 'p' {
+	if c|32 == 'p' {
 		e2 = scanexp(tls, f, pok)
-		if e2 == (-0x7fffffffffffffff - int64(1)) {
+		if e2 == -0x7fffffffffffffff-int64(1) {
 			if pok != 0 {
-				if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+				if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 					(*FILE)(unsafe.Pointer(f)).rpos--
 				} else {
 				}
@@ -1299,23 +1299,23 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 			e2 = int64(0)
 		}
 	} else {
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
 	}
-	e2 = e2 + ((int64(4) * rp) - int64(32))
+	e2 = e2 + (int64(4)*rp - int64(32))
 
 	if !(x != 0) {
-		return (float64(sign) * 0.0)
+		return float64(sign) * 0.0
 	}
 	if e2 > int64(-emin) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
-		return ((float64(sign) * 1.79769313486231570815e+308) * 1.79769313486231570815e+308)
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
+		return float64(sign) * 1.79769313486231570815e+308 * 1.79769313486231570815e+308
 	}
-	if e2 < (int64(emin - (2 * 53))) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
-		return ((float64(sign) * 2.22507385850720138309e-308) * 2.22507385850720138309e-308)
+	if e2 < int64(emin-2*53) {
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
+		return float64(sign) * 2.22507385850720138309e-308 * 2.22507385850720138309e-308
 	}
 
 	for x < 0x80000000 {
@@ -1323,33 +1323,33 @@ func hexfloat(tls *TLS, f uintptr, bits int32, emin int32, sign int32, pok int32
 			x = x + (x + uint32_t(1))
 			y = y + (y - float64(1))
 		} else {
-			x = x + (x)
-			y = y + (y)
+			x = x + x
+			y = y + y
 		}
 		e2--
 	}
 
-	if int64(bits) > ((int64(32) + e2) - int64(emin)) {
-		bits = (int32((int64(32) + e2) - int64(emin)))
+	if int64(bits) > int64(32)+e2-int64(emin) {
+		bits = int32(int64(32) + e2 - int64(emin))
 		if bits < 0 {
 			bits = 0
 		}
 	}
 
 	if bits < 53 {
-		bias = Xcopysignl(tls, Xscalbn(tls, float64(1), (((32+53)-bits)-1)), float64(sign))
+		bias = Xcopysignl(tls, Xscalbn(tls, float64(1), 32+53-bits-1), float64(sign))
 	}
 
-	if ((bits < 32) && (y != 0)) && !((x & uint32_t(1)) != 0) {
+	if bits < 32 && y != 0 && !(x&uint32_t(1) != 0) {
 		x++
 		y = float64(0)
 	}
 
-	y = ((bias + (float64(sign) * float64(x))) + (float64(sign) * y))
-	y = y - (bias)
+	y = bias + float64(sign)*float64(x) + float64(sign)*y
+	y = y - bias
 
 	if !(y != 0) {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
 	}
 
 	return Xscalbnl(tls, y, int32(e2))
@@ -1365,70 +1365,70 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) float64 { /* float
 	switch prec {
 	case 0:
 		bits = 24
-		emin = ((-125) - bits)
+		emin = -125 - bits
 		break
 	case 1:
 		bits = 53
-		emin = ((-1021) - bits)
+		emin = -1021 - bits
 		break
 	case 2:
 		bits = 53
-		emin = ((-1021) - bits)
+		emin = -1021 - bits
 		break
 	default:
 		return float64(0)
 	}
 
 	for __isspace(tls, AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}())) != 0 {
 	}
 
-	if (c == '+') || (c == '-') {
-		sign = sign - (2 * (Bool32(c == '-')))
+	if c == '+' || c == '-' {
+		sign = sign - 2*Bool32(c == '-')
 		c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
 		}()
 	}
 
-	for i = uint64(0); (i < uint64(8)) && ((c | 32) == int32(*(*int8)(unsafe.Pointer(ts /* "infinity" */ + uintptr(i))))); i++ {
+	for i = uint64(0); i < uint64(8) && c|32 == int32(*(*int8)(unsafe.Pointer(ts /* "infinity" */ + uintptr(i)))); i++ {
 		if i < uint64(7) {
 			c = func() int32 {
-				if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+				if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 					return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 				}
 				return X__shgetc(tls, f)
 			}()
 		}
 	}
-	if ((i == uint64(3)) || (i == uint64(8))) || ((i > uint64(3)) && (pok != 0)) {
+	if i == uint64(3) || i == uint64(8) || i > uint64(3) && pok != 0 {
 		if i != uint64(8) {
-			if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+			if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 				(*FILE)(unsafe.Pointer(f)).rpos--
 			} else {
 			}
 			if pok != 0 {
 				for ; i > uint64(3); i-- {
-					if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+					if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 						(*FILE)(unsafe.Pointer(f)).rpos--
 					} else {
 					}
 				}
 			}
 		}
-		return (float64(float32(sign) * X__builtin_inff(tls)))
+		return float64(float32(sign) * X__builtin_inff(tls))
 	}
 	if !(i != 0) {
-		for i = uint64(0); (i < uint64(3)) && ((c | 32) == int32(*(*int8)(unsafe.Pointer(ts + 9 /* "nan" */ + uintptr(i))))); i++ {
+		for i = uint64(0); i < uint64(3) && c|32 == int32(*(*int8)(unsafe.Pointer(ts + 9 /* "nan" */ + uintptr(i)))); i++ {
 			if i < uint64(2) {
 				c = func() int32 {
-					if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+					if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 						return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 					}
 					return X__shgetc(tls, f)
@@ -1437,72 +1437,72 @@ func X__floatscan(tls *TLS, f uintptr, prec int32, pok int32) float64 { /* float
 		}
 	}
 	if i == uint64(3) {
-		if (func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if func() int32 {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
-		}()) != '(' {
-			if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		}() != '(' {
+			if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 				(*FILE)(unsafe.Pointer(f)).rpos--
 			} else {
 			}
-			return float64(X__builtin_nanf(tls, ts+13 /* "" */))
+			return float64(X__builtin_nanf(tls, ts+13))
 		}
 		for i = uint64(1); ; i++ {
 			c = func() int32 {
-				if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+				if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 					return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 				}
 				return X__shgetc(tls, f)
 			}()
-			if ((((uint32(c - '0')) < 10) || ((uint32(c - 'A')) < 26)) || ((uint32(c - 'a')) < 26)) || (c == '_') {
+			if uint32(c-'0') < 10 || uint32(c-'A') < 26 || uint32(c-'a') < 26 || c == '_' {
 				continue
 			}
 			if c == ')' {
-				return float64(X__builtin_nanf(tls, ts+13 /* "" */))
+				return float64(X__builtin_nanf(tls, ts+13))
 			}
-			if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+			if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 				(*FILE)(unsafe.Pointer(f)).rpos--
 			} else {
 			}
 			if !(pok != 0) {
-				(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22
+				*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 				X__shlim(tls, f, int64(0))
 				return float64(0)
 			}
 			for PostDecUint64(&i, 1) != 0 {
-				if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+				if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 					(*FILE)(unsafe.Pointer(f)).rpos--
 				} else {
 				}
 			}
-			return float64(X__builtin_nanf(tls, ts+13 /* "" */))
+			return float64(X__builtin_nanf(tls, ts+13))
 		}
-		return float64(X__builtin_nanf(tls, ts+13 /* "" */))
+		return float64(X__builtin_nanf(tls, ts+13))
 	}
 
 	if i != 0 {
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 		X__shlim(tls, f, int64(0))
 		return float64(0)
 	}
 
 	if c == '0' {
 		c = func() int32 {
-			if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+			if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 				return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 			}
 			return X__shgetc(tls, f)
 		}()
-		if (c | 32) == 'x' {
+		if c|32 == 'x' {
 			return hexfloat(tls, f, bits, emin, sign, pok)
 		}
-		if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+		if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 			(*FILE)(unsafe.Pointer(f)).rpos--
 		} else {
 		}
@@ -1539,18 +1539,18 @@ func X__intscan(tls *TLS, f uintptr, base uint32, pok int32, lim uint64) uint64
 	var x uint32
 	var y uint64
 	var bs int32
-	val = (uintptr(unsafe.Pointer(&table1)) + uintptr(1))
+	val = uintptr(unsafe.Pointer(&table1)) + uintptr(1)
 	neg = 0
-	if !((base > uint32(36)) || (base == uint32(1))) {
+	if !(base > uint32(36) || base == uint32(1)) {
 		goto __1
 	}
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 	return uint64(0)
 __1:
 	;
 __2:
 	if !(__isspace(tls, AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1560,32 +1560,32 @@ __2:
 	goto __2
 __3:
 	;
-	if !((c == '+') || (c == '-')) {
+	if !(c == '+' || c == '-') {
 		goto __4
 	}
-	neg = -(Bool32(c == '-'))
+	neg = -Bool32(c == '-')
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}()
 __4:
 	;
-	if !(((base == uint32(0)) || (base == uint32(16))) && (c == '0')) {
+	if !((base == uint32(0) || base == uint32(16)) && c == '0') {
 		goto __5
 	}
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
 	}()
-	if !((c | 32) == 'x') {
+	if !(c|32 == 'x') {
 		goto __7
 	}
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1593,14 +1593,14 @@ __4:
 	if !(int32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= 16) {
 		goto __9
 	}
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
 	if !(pok != 0) {
 		goto __10
 	}
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
@@ -1634,12 +1634,12 @@ __13:
 	if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) >= base) {
 		goto __14
 	}
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
 	X__shlim(tls, f, int64(0))
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 22
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 22
 	return uint64(0)
 __14:
 	;
@@ -1650,14 +1650,14 @@ __6:
 	}
 	x = uint32(0)
 __17:
-	if !(((uint32(c - '0')) < 10) && (x <= ((0xffffffff / uint32(10)) - uint32(1)))) {
+	if !(uint32(c-'0') < 10 && x <= 0xffffffff/uint32(10)-uint32(1)) {
 		goto __19
 	}
-	x = ((x * uint32(10)) + (uint32(c - '0')))
+	x = x*uint32(10) + uint32(c-'0')
 	goto __18
 __18:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1668,14 +1668,14 @@ __19:
 	;
 	y = uint64(x)
 __20:
-	if !((((uint32(c - '0')) < 10) && (y <= (((2 * uint64(0x7fffffffffffffff)) + uint64(1)) / uint64(10)))) && ((uint64(10) * y) <= (((2 * uint64(0x7fffffffffffffff)) + uint64(1)) - (uint64(c - '0'))))) {
+	if !(uint32(c-'0') < 10 && y <= (2*uint64(0x7fffffffffffffff)+uint64(1))/uint64(10) && uint64(10)*y <= 2*uint64(0x7fffffffffffffff)+uint64(1)-uint64(c-'0')) {
 		goto __22
 	}
-	y = ((y * uint64(10)) + (uint64(c - '0')))
+	y = y*uint64(10) + uint64(c-'0')
 	goto __21
 __21:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1684,7 +1684,7 @@ __21:
 	goto __22
 __22:
 	;
-	if !((uint32(c - '0')) >= 10) {
+	if !(uint32(c-'0') >= 10) {
 		goto __23
 	}
 	goto done
@@ -1692,20 +1692,20 @@ __23:
 	;
 	goto __16
 __15:
-	if !(!((base & (base - uint32(1))) != 0)) {
+	if !!(base&(base-uint32(1)) != 0) {
 		goto __24
 	}
-	bs = int32(*(*int8)(unsafe.Pointer(ts + 14 /* "\x00\x01\x02\x04\a\x03\x06\x05" */ + uintptr((((uint32(0x17) * base) >> 5) & uint32(7))))))
+	bs = int32(*(*int8)(unsafe.Pointer(ts + 14 + uintptr(uint32(0x17)*base>>5&uint32(7)))))
 	x = uint32(0)
 __26:
-	if !((uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base) && (x <= (0xffffffff / uint32(32)))) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= 0xffffffff/uint32(32)) {
 		goto __28
 	}
-	x = ((x << bs) | uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))))
+	x = x<<bs | uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c))))
 	goto __27
 __27:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1716,14 +1716,14 @@ __28:
 	;
 	y = uint64(x)
 __29:
-	if !((uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base) && (y <= (uint64(((2 * uint64(0x7fffffffffffffff)) + uint64(1))) >> bs))) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && y <= uint64(2*uint64(0x7fffffffffffffff)+uint64(1))>>bs) {
 		goto __31
 	}
-	y = ((y << bs) | uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c)))))
+	y = y<<bs | uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c))))
 	goto __30
 __30:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1736,14 +1736,14 @@ __31:
 __24:
 	x = uint32(0)
 __32:
-	if !((uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base) && (x <= ((0xffffffff / uint32(36)) - uint32(1)))) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && x <= 0xffffffff/uint32(36)-uint32(1)) {
 		goto __34
 	}
-	x = ((x * base) + uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))))
+	x = x*base + uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c))))
 	goto __33
 __33:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1754,14 +1754,14 @@ __34:
 	;
 	y = uint64(x)
 __35:
-	if !(((uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base) && (y <= (((2 * uint64(0x7fffffffffffffff)) + uint64(1)) / uint64(base)))) && ((uint64(base) * y) <= (((2 * uint64(0x7fffffffffffffff)) + uint64(1)) - uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c))))))) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(val + uintptr(c)))) < base && y <= (2*uint64(0x7fffffffffffffff)+uint64(1))/uint64(base) && uint64(base)*y <= 2*uint64(0x7fffffffffffffff)+uint64(1)-uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c))))) {
 		goto __37
 	}
-	y = ((y * uint64(base)) + uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c)))))
+	y = y*uint64(base) + uint64(*(*uint8)(unsafe.Pointer(val + uintptr(c))))
 	goto __36
 __36:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1784,7 +1784,7 @@ __39:
 	goto __40
 __40:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -1793,9 +1793,9 @@ __40:
 	goto __41
 __41:
 	;
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
 	y = lim
-	if !((lim & uint64(1)) != 0) {
+	if !(lim&uint64(1) != 0) {
 		goto __42
 	}
 	neg = 0
@@ -1804,24 +1804,24 @@ __42:
 __38:
 	;
 done:
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
 	if !(y >= lim) {
 		goto __43
 	}
-	if !(!((lim & uint64(1)) != 0) && !(neg != 0)) {
+	if !(!(lim&uint64(1) != 0) && !(neg != 0)) {
 		goto __44
 	}
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
-	return (lim - uint64(1))
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
+	return lim - uint64(1)
 	goto __45
 __44:
 	if !(y > lim) {
 		goto __46
 	}
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 34
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 34
 	return lim
 __46:
 	;
@@ -1829,7 +1829,7 @@ __45:
 	;
 __43:
 	;
-	return ((y ^ uint64(neg)) - uint64(neg))
+	return y ^ uint64(neg) - uint64(neg)
 }
 
 // The shcnt field stores the number of bytes read so far, offset by
@@ -1839,10 +1839,10 @@ __43:
 
 func X__shlim(tls *TLS, f uintptr, lim off_t) { /* shgetc.c:8:6: */
 	(*FILE)(unsafe.Pointer(f)).shlim = lim
-	(*FILE)(unsafe.Pointer(f)).shcnt = ((int64((*FILE)(unsafe.Pointer(f)).buf) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1)
+	(*FILE)(unsafe.Pointer(f)).shcnt = (int64((*FILE)(unsafe.Pointer(f)).buf) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1
 	// If lim is nonzero, rend must be a valid pointer.
-	if (lim != 0) && (((int64((*FILE)(unsafe.Pointer(f)).rend) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1) > lim) {
-		(*FILE)(unsafe.Pointer(f)).shend = ((*FILE)(unsafe.Pointer(f)).rpos + uintptr(lim))
+	if lim != 0 && (int64((*FILE)(unsafe.Pointer(f)).rend)-int64((*FILE)(unsafe.Pointer(f)).rpos))/1 > lim {
+		(*FILE)(unsafe.Pointer(f)).shend = (*FILE)(unsafe.Pointer(f)).rpos + uintptr(lim)
 	} else {
 		(*FILE)(unsafe.Pointer(f)).shend = (*FILE)(unsafe.Pointer(f)).rend
 	}
@@ -1850,20 +1850,20 @@ func X__shlim(tls *TLS, f uintptr, lim off_t) { /* shgetc.c:8:6: */
 
 func X__shgetc(tls *TLS, f uintptr) int32 { /* shgetc.c:19:5: */
 	var c int32
-	var cnt off_t = ((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1))
-	if (((*FILE)(unsafe.Pointer(f)).shlim != 0) && (cnt >= (*FILE)(unsafe.Pointer(f)).shlim)) || ((AssignInt32(&c, X__uflow(tls, f))) < 0) {
-		(*FILE)(unsafe.Pointer(f)).shcnt = (((int64((*FILE)(unsafe.Pointer(f)).buf) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1) + cnt)
+	var cnt off_t = (*FILE)(unsafe.Pointer(f)).shcnt + (int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1
+	if (*FILE)(unsafe.Pointer(f)).shlim != 0 && cnt >= (*FILE)(unsafe.Pointer(f)).shlim || AssignInt32(&c, X__uflow(tls, f)) < 0 {
+		(*FILE)(unsafe.Pointer(f)).shcnt = (int64((*FILE)(unsafe.Pointer(f)).buf)-int64((*FILE)(unsafe.Pointer(f)).rpos))/1 + cnt
 		(*FILE)(unsafe.Pointer(f)).shend = (*FILE)(unsafe.Pointer(f)).rpos
 		(*FILE)(unsafe.Pointer(f)).shlim = int64(-1)
 		return -1
 	}
 	cnt++
-	if ((*FILE)(unsafe.Pointer(f)).shlim != 0) && (((int64((*FILE)(unsafe.Pointer(f)).rend) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1) > ((*FILE)(unsafe.Pointer(f)).shlim - cnt)) {
-		(*FILE)(unsafe.Pointer(f)).shend = ((*FILE)(unsafe.Pointer(f)).rpos + uintptr(((*FILE)(unsafe.Pointer(f)).shlim - cnt)))
+	if (*FILE)(unsafe.Pointer(f)).shlim != 0 && (int64((*FILE)(unsafe.Pointer(f)).rend)-int64((*FILE)(unsafe.Pointer(f)).rpos))/1 > (*FILE)(unsafe.Pointer(f)).shlim-cnt {
+		(*FILE)(unsafe.Pointer(f)).shend = (*FILE)(unsafe.Pointer(f)).rpos + uintptr((*FILE)(unsafe.Pointer(f)).shlim-cnt)
 	} else {
 		(*FILE)(unsafe.Pointer(f)).shend = (*FILE)(unsafe.Pointer(f)).rend
 	}
-	(*FILE)(unsafe.Pointer(f)).shcnt = (((int64((*FILE)(unsafe.Pointer(f)).buf) - int64((*FILE)(unsafe.Pointer(f)).rpos)) / 1) + cnt)
+	(*FILE)(unsafe.Pointer(f)).shcnt = (int64((*FILE)(unsafe.Pointer(f)).buf)-int64((*FILE)(unsafe.Pointer(f)).rpos))/1 + cnt
 	if (*FILE)(unsafe.Pointer(f)).rpos <= (*FILE)(unsafe.Pointer(f)).buf {
 		*(*uint8)(unsafe.Pointer((*FILE)(unsafe.Pointer(f)).rpos + UintptrFromInt32(-1))) = uint8(c)
 	}
@@ -1907,7 +1907,7 @@ type lconv = struct {
 // POSIX/SUS requirements follow. These numbers come directly
 // from SUS and have nothing to do with the host system.
 
-var posix_lconv = lconv{decimal_point: ts + 23 /* "." */, thousands_sep: ts + 13 /* "" */, grouping: ts + 13 /* "" */, int_curr_symbol: ts + 13 /* "" */, currency_symbol: ts + 13 /* "" */, mon_decimal_point: ts + 13 /* "" */, mon_thousands_sep: ts + 13 /* "" */, mon_grouping: ts + 13 /* "" */, positive_sign: ts + 13 /* "" */, negative_sign: ts + 13 /* "" */, int_frac_digits: Int8FromInt32(255), frac_digits: Int8FromInt32(255), p_cs_precedes: Int8FromInt32(255), p_sep_by_space: Int8FromInt32(255), n_cs_precedes: Int8FromInt32(255), n_sep_by_space: Int8FromInt32(255), p_sign_posn: Int8FromInt32(255), n_sign_posn: Int8FromInt32(255), int_p_cs_precedes: Int8FromInt32(255), int_p_sep_by_space: Int8FromInt32(255), int_n_cs_precedes: Int8FromInt32(255), int_n_sep_by_space: Int8FromInt32(255), int_p_sign_posn: Int8FromInt32(255), int_n_sign_posn: Int8FromInt32(255)} /* localeconv.c:4:27 */
+var posix_lconv = lconv{decimal_point: ts + 23, thousands_sep: ts + 13, grouping: ts + 13, int_curr_symbol: ts + 13, currency_symbol: ts + 13, mon_decimal_point: ts + 13, mon_thousands_sep: ts + 13, mon_grouping: ts + 13, positive_sign: ts + 13, negative_sign: ts + 13, int_frac_digits: Int8FromInt32(255), frac_digits: Int8FromInt32(255), p_cs_precedes: Int8FromInt32(255), p_sep_by_space: Int8FromInt32(255), n_cs_precedes: Int8FromInt32(255), n_sep_by_space: Int8FromInt32(255), p_sign_posn: Int8FromInt32(255), n_sign_posn: Int8FromInt32(255), int_p_cs_precedes: Int8FromInt32(255), int_p_sep_by_space: Int8FromInt32(255), int_n_cs_precedes: Int8FromInt32(255), int_n_sep_by_space: Int8FromInt32(255), int_p_sign_posn: Int8FromInt32(255), int_n_sign_posn: Int8FromInt32(255)} /* localeconv.c:4:27 */
 
 func Xlocaleconv(tls *TLS) uintptr { /* localeconv.c:31:14: */
 	return uintptr(unsafe.Pointer(&posix_lconv))
@@ -1917,19 +1917,19 @@ func X__fpclassify(tls *TLS, x float64) int32 { /* __fpclassify.c:4:5: */
 	bp := tls.Alloc(8)
 	defer tls.Free(8)
 
-	*(*struct{ f float64 })(unsafe.Pointer(bp /* u */)) = func() (r struct{ f float64 }) {
+	*(*struct{ f float64 })(unsafe.Pointer(bp)) = func() (r struct{ f float64 }) {
 		*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = x
 		return r
 	}()
-	var e int32 = (int32((*(*uint64_t)(unsafe.Pointer(bp /* &u */)) >> 52) & uint64(0x7ff)))
+	var e int32 = int32(*(*uint64_t)(unsafe.Pointer(bp)) >> 52 & uint64(0x7ff))
 	if !(e != 0) {
-		if (*(*uint64_t)(unsafe.Pointer(bp /* &u */)) << 1) != 0 {
+		if *(*uint64_t)(unsafe.Pointer(bp))<<1 != 0 {
 			return 3
 		}
 		return 2
 	}
 	if e == 0x7ff {
-		if (*(*uint64_t)(unsafe.Pointer(bp /* &u */)) << 12) != 0 {
+		if *(*uint64_t)(unsafe.Pointer(bp))<<12 != 0 {
 			return 0
 		}
 		return 1
@@ -1941,19 +1941,19 @@ func X__fpclassifyf(tls *TLS, x float32) int32 { /* __fpclassifyf.c:4:5: */
 	bp := tls.Alloc(4)
 	defer tls.Free(4)
 
-	*(*struct{ f float32 })(unsafe.Pointer(bp /* u */)) = func() (r struct{ f float32 }) {
+	*(*struct{ f float32 })(unsafe.Pointer(bp)) = func() (r struct{ f float32 }) {
 		*(*float32)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = x
 		return r
 	}()
-	var e int32 = (int32((*(*uint32_t)(unsafe.Pointer(bp /* &u */)) >> 23) & uint32_t(0xff)))
+	var e int32 = int32(*(*uint32_t)(unsafe.Pointer(bp)) >> 23 & uint32_t(0xff))
 	if !(e != 0) {
-		if (*(*uint32_t)(unsafe.Pointer(bp /* &u */)) << 1) != 0 {
+		if *(*uint32_t)(unsafe.Pointer(bp))<<1 != 0 {
 			return 3
 		}
 		return 2
 	}
 	if e == 0xff {
-		if (*(*uint32_t)(unsafe.Pointer(bp /* &u */)) << 9) != 0 {
+		if *(*uint32_t)(unsafe.Pointer(bp))<<9 != 0 {
 			return 0
 		}
 		return 1
@@ -1978,30 +1978,30 @@ func Xfmodl(tls *TLS, x float64, y float64) float64 { /* fmodl.c:4:13: */
 }
 
 func Xnanf(tls *TLS, s uintptr) float32 { /* nanf.c:3:7: */
-	return X__builtin_nanf(tls, ts+13 /* "" */)
+	return X__builtin_nanf(tls, ts+13)
 }
 
-var toint double_t = (float64(float64(1)) / 2.22044604925031308085e-16) /* rint.c:10:23 */
+var toint double_t = float64(float64(1)) / 2.22044604925031308085e-16 /* rint.c:10:23 */
 
 func Xrint(tls *TLS, x float64) float64 { /* rint.c:12:8: */
 	bp := tls.Alloc(8)
 	defer tls.Free(8)
 
-	*(*struct{ f float64 })(unsafe.Pointer(bp /* u */)) = func() (r struct{ f float64 }) {
+	*(*struct{ f float64 })(unsafe.Pointer(bp)) = func() (r struct{ f float64 }) {
 		*(*float64)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + 0)) = x
 		return r
 	}()
-	var e int32 = (int32((*(*uint64_t)(unsafe.Pointer(bp /* &u */)) >> 52) & uint64(0x7ff)))
-	var s int32 = (int32(*(*uint64_t)(unsafe.Pointer(bp /* &u */)) >> 63))
+	var e int32 = int32(*(*uint64_t)(unsafe.Pointer(bp)) >> 52 & uint64(0x7ff))
+	var s int32 = int32(*(*uint64_t)(unsafe.Pointer(bp)) >> 63)
 	var y double_t
 
-	if e >= (0x3ff + 52) {
+	if e >= 0x3ff+52 {
 		return x
 	}
 	if s != 0 {
-		y = ((x - toint) + toint)
+		y = x - toint + toint
 	} else {
-		y = ((x + toint) - toint)
+		y = x + toint - toint
 	}
 	if y == float64(0) {
 		if s != 0 {
@@ -2021,11 +2021,11 @@ func Xscalbn(tls *TLS, x float64, n int32) float64 { /* scalbn.c:4:8: */
 	var y double_t = x
 
 	if n > 1023 {
-		y = y * (0x1p1023)
-		n = n - (1023)
+		y = y * 0x1p1023
+		n = n - 1023
 		if n > 1023 {
-			y = y * (0x1p1023)
-			n = n - (1023)
+			y = y * 0x1p1023
+			n = n - 1023
 			if n > 1023 {
 				n = 1023
 			}
@@ -2043,8 +2043,8 @@ func Xscalbn(tls *TLS, x float64, n int32) float64 { /* scalbn.c:4:8: */
 			}
 		}
 	}
-	*(*uint64_t)(unsafe.Pointer(bp /* &u */)) = ((uint64_t(0x3ff + n)) << 52)
-	x = (y * *(*float64)(unsafe.Pointer(bp /* &u */)))
+	*(*uint64_t)(unsafe.Pointer(bp)) = uint64_t(0x3ff+n) << 52
+	x = y * *(*float64)(unsafe.Pointer(bp))
 	return x
 }
 
@@ -2347,7 +2347,7 @@ func a_ctz_64(tls *TLS, x uint64_t) int32 { /* atomic_arch.h:112:19: */
 }
 
 func a_ctz_32(tls *TLS, x uint32_t) int32 { /* atomic.h:256:19: */
-	return int32(_sdebruijn328[(((x & -x) * uint32_t(0x076be629)) >> 27)])
+	return int32(_sdebruijn328[x&-x*uint32_t(0x076be629)>>27])
 }
 
 var _sdebruijn328 = [32]int8{
@@ -2374,14 +2374,14 @@ func __wake(tls *TLS, addr uintptr, cnt int32, priv int32) { /* pthread_impl.h:1
 	if cnt < 0 {
 		cnt = 0x7fffffff
 	}
-	_ = (Bool32((X__syscall3(tls, int64(202), int64(addr), (int64(1|priv)), int64(cnt)) != int64(-38)) || (X__syscall3(tls, int64(202), int64(addr), int64(1), int64(cnt)) != 0)))
+	_ = Bool32(X__syscall3(tls, int64(202), int64(addr), int64(1|priv), int64(cnt)) != int64(-38) || X__syscall3(tls, int64(202), int64(addr), int64(1), int64(cnt)) != 0)
 }
 
 func __futexwait(tls *TLS, addr uintptr, val int32, priv int32) { /* pthread_impl.h:162:20: */
 	if priv != 0 {
 		priv = 128
 	}
-	_ = (Bool32((X__syscall4(tls, int64(202), int64(addr), (int64(0|priv)), int64(val), int64(0)) != int64(-38)) || (X__syscall4(tls, int64(202), int64(addr), int64(0), int64(val), int64(0)) != 0)))
+	_ = Bool32(X__syscall4(tls, int64(202), int64(addr), int64(0|priv), int64(val), int64(0)) != int64(-38) || X__syscall4(tls, int64(202), int64(addr), int64(0), int64(val), int64(0)) != 0)
 }
 
 var X__fsmu8 = [51]uint32_t{
@@ -2389,989 +2389,989 @@ var X__fsmu8 = [51]uint32_t{
 		if 0x2 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x2))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x2)
 	}(), func() uint32 {
 		if 0x3 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x3))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x3)
 	}(), func() uint32 {
 		if 0x4 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x4))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x4)
 	}(), func() uint32 {
 		if 0x5 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x5))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x5)
 	}(), func() uint32 {
 		if 0x6 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x6))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x6)
 	}(), func() uint32 {
 		if 0x7 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x7))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x7)
 	}(),
 	func() uint32 {
 		if 0x8 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x8))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x8)
 	}(), func() uint32 {
 		if 0x9 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0x9))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x9)
 	}(), func() uint32 {
 		if 0xa < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xa))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xa)
 	}(), func() uint32 {
 		if 0xb < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xb))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xb)
 	}(), func() uint32 {
 		if 0xc < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xc))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xc)
 	}(), func() uint32 {
 		if 0xd < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xd))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xd)
 	}(), func() uint32 {
 		if 0xe < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xe))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xe)
 	}(), func() uint32 {
 		if 0xf < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | uint32_t(0xf))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xf)
 	}(),
 	func() uint32 {
-		if (0x0 + 16) < 2 {
+		if 0x0+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x0 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x0+16)
 	}(), func() uint32 {
-		if (0x1 + 16) < 2 {
+		if 0x1+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x1 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x1+16)
 	}(), func() uint32 {
-		if (0x2 + 16) < 2 {
+		if 0x2+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x2 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x2+16)
 	}(), func() uint32 {
-		if (0x3 + 16) < 2 {
+		if 0x3+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x3 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x3+16)
 	}(), func() uint32 {
-		if (0x4 + 16) < 2 {
+		if 0x4+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x4 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x4+16)
 	}(), func() uint32 {
-		if (0x5 + 16) < 2 {
+		if 0x5+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x5 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x5+16)
 	}(), func() uint32 {
-		if (0x6 + 16) < 2 {
+		if 0x6+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x6 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x6+16)
 	}(), func() uint32 {
-		if (0x7 + 16) < 2 {
+		if 0x7+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x7 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x7+16)
 	}(),
 	func() uint32 {
-		if (0x8 + 16) < 2 {
+		if 0x8+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x8 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x8+16)
 	}(), func() uint32 {
-		if (0x9 + 16) < 2 {
+		if 0x9+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0x9 + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0x9+16)
 	}(), func() uint32 {
-		if (0xa + 16) < 2 {
+		if 0xa+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xa + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xa+16)
 	}(), func() uint32 {
-		if (0xb + 16) < 2 {
+		if 0xb+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xb + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xb+16)
 	}(), func() uint32 {
-		if (0xc + 16) < 2 {
+		if 0xc+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xc + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xc+16)
 	}(), func() uint32 {
-		if (0xd + 16) < 2 {
+		if 0xd+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xd + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xd+16)
 	}(), func() uint32 {
-		if (0xe + 16) < 2 {
+		if 0xe+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xe + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xe+16)
 	}(), func() uint32 {
-		if (0xf + 16) < 2 {
+		if 0xf+16 < 2 {
 			return Uint32FromInt32(-1)
 		}
-		return (((func() uint32 {
+		return func() uint32 {
 			if Int32(0x80) == Int32(0x80) {
-				return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+				return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 			}
-			return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-		}()) << 23) | (uint32_t(0xf + 16)))
+			return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+		}()<<23 | uint32_t(0xf+16)
 	}(),
-	(((func() uint32 {
+	func() uint32 {
 		if 0x0 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x0 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x0)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x0), func() uint32 {
 		if 0x1 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x1 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x1)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x1), func() uint32 {
 		if 0x2 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x2 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x2)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x2), func() uint32 {
 		if 0x3 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x3 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x3)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x3), func() uint32 {
 		if 0x4 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x4 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x4)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x4), func() uint32 {
 		if 0x5 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x5 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x5)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x5), func() uint32 {
 		if 0x6 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x6 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x6)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x6), func() uint32 {
 		if 0x7 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x7 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x7)),
-	(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x7),
+	func() uint32 {
 		if 0x8 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x8 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x8)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x8), func() uint32 {
 		if 0x9 == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0x9 == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0x9)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0x9), func() uint32 {
 		if 0xa == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xa == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xa)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xa), func() uint32 {
 		if 0xb == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xb == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xb)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xb), func() uint32 {
 		if 0xc == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xc == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xc)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xc), func() uint32 {
 		if 0xd == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xd == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xd)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xd), func() uint32 {
 		if 0xe == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xe == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xe)), (((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xe), func() uint32 {
 		if 0xf == 0 {
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0xa0) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0xa0)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0xa0))
+			}() << 23
 		}
 		return func() uint32 {
 			if 0xf == 0xd {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xa0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xa0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}
-			return ((func() uint32 {
+			return func() uint32 {
 				if Int32(0x80) == Int32(0x80) {
-					return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+					return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 				}
-				return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-			}()) << 23)
+				return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+			}() << 23
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | uint32_t(0xf)),
-	((((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(0xf),
+	func() uint32 {
 		if 0x0 >= 5 {
 			return uint32(0)
 		}
 		return func() uint32 {
 			if 0x0 == 0 {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x90) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x90)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
+				}() << 23
 			}
 			return func() uint32 {
 				if 0x0 == 4 {
-					return ((func() uint32 {
+					return func() uint32 {
 						if Int32(0x80) == Int32(0x80) {
-							return (Uint32(Uint32(0x40) - Uint32FromInt32(0x90)))
+							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
 						}
-						return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-					}()) << 23)
+						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+					}() << 23
 				}
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}()
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | (uint32_t(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 12)) | uint32_t(0x0)), ((((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>12 | uint32_t(0x0), func() uint32 {
 		if 0x1 >= 5 {
 			return uint32(0)
 		}
 		return func() uint32 {
 			if 0x1 == 0 {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x90) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x90)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
+				}() << 23
 			}
 			return func() uint32 {
 				if 0x1 == 4 {
-					return ((func() uint32 {
+					return func() uint32 {
 						if Int32(0x80) == Int32(0x80) {
-							return (Uint32(Uint32(0x40) - Uint32FromInt32(0x90)))
+							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
 						}
-						return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-					}()) << 23)
+						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+					}() << 23
 				}
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}()
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | (uint32_t(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 12)) | uint32_t(0x1)), ((((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>12 | uint32_t(0x1), func() uint32 {
 		if 0x2 >= 5 {
 			return uint32(0)
 		}
 		return func() uint32 {
 			if 0x2 == 0 {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x90) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x90)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
+				}() << 23
 			}
 			return func() uint32 {
 				if 0x2 == 4 {
-					return ((func() uint32 {
+					return func() uint32 {
 						if Int32(0x80) == Int32(0x80) {
-							return (Uint32(Uint32(0x40) - Uint32FromInt32(0x90)))
+							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
 						}
-						return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-					}()) << 23)
+						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+					}() << 23
 				}
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}()
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | (uint32_t(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 12)) | uint32_t(0x2)), ((((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>12 | uint32_t(0x2), func() uint32 {
 		if 0x3 >= 5 {
 			return uint32(0)
 		}
 		return func() uint32 {
 			if 0x3 == 0 {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x90) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x90)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
+				}() << 23
 			}
 			return func() uint32 {
 				if 0x3 == 4 {
-					return ((func() uint32 {
+					return func() uint32 {
 						if Int32(0x80) == Int32(0x80) {
-							return (Uint32(Uint32(0x40) - Uint32FromInt32(0x90)))
+							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
 						}
-						return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-					}()) << 23)
+						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+					}() << 23
 				}
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}()
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | (uint32_t(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 12)) | uint32_t(0x3)), ((((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>12 | uint32_t(0x3), func() uint32 {
 		if 0x4 >= 5 {
 			return uint32(0)
 		}
 		return func() uint32 {
 			if 0x4 == 0 {
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x90) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x90)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x90))
+				}() << 23
 			}
 			return func() uint32 {
 				if 0x4 == 4 {
-					return ((func() uint32 {
+					return func() uint32 {
 						if Int32(0x80) == Int32(0x80) {
-							return (Uint32(Uint32(0x40) - Uint32FromInt32(0x90)))
+							return Uint32(Uint32(0x40) - Uint32FromInt32(0x90))
 						}
-						return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-					}()) << 23)
+						return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+					}() << 23
 				}
-				return ((func() uint32 {
+				return func() uint32 {
 					if Int32(0x80) == Int32(0x80) {
-						return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+						return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 					}
-					return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-				}()) << 23)
+					return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+				}() << 23
 			}()
 		}()
-	}()) | (uint32_t(((func() uint32 {
+	}() | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 6)) | (uint32_t(((func() uint32 {
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>6 | uint32_t(func() uint32 {
 		if Int32(0x80) == Int32(0x80) {
-			return (Uint32(Uint32(0x40) - Uint32FromInt32(0xc0)))
+			return Uint32(Uint32(0x40) - Uint32FromInt32(0xc0))
 		}
-		return (Uint32(Uint32(0) - Uint32FromInt32(0x80)))
-	}()) << 23)) >> 12)) | uint32_t(0x4)),
+		return Uint32(Uint32(0) - Uint32FromInt32(0x80))
+	}()<<23)>>12 | uint32_t(0x4),
 } /* internal.c:18:16 */
 
 type wint_t = uint32 /* alltypes.h:198:18 */
@@ -3396,7 +3396,7 @@ func Xmbrtowc(tls *TLS, wc uintptr, src uintptr, n size_t, st uintptr) size_t {
 	s = src
 	N = uint32(n)
 
-	if !(!(st != 0)) {
+	if !!(st != 0) {
 		goto __1
 	}
 	st = uintptr(unsafe.Pointer(&_sinternal_state))
@@ -3404,7 +3404,7 @@ __1:
 	;
 	c = *(*uint32)(unsafe.Pointer(st))
 
-	if !(!(s != 0)) {
+	if !!(s != 0) {
 		goto __2
 	}
 	if !(c != 0) {
@@ -3416,7 +3416,7 @@ __4:
 	return uint64(0)
 	goto __3
 __2:
-	if !(!(wc != 0)) {
+	if !!(wc != 0) {
 		goto __5
 	}
 	wc = bp /* &dummy */
@@ -3425,40 +3425,40 @@ __5:
 __3:
 	;
 
-	if !(!(n != 0)) {
+	if !!(n != 0) {
 		goto __6
 	}
 	return Uint64FromInt32(-2)
 __6:
 	;
-	if !(!(c != 0)) {
+	if !!(c != 0) {
 		goto __7
 	}
 	if !(int32(*(*uint8)(unsafe.Pointer(s))) < 0x80) {
 		goto __8
 	}
-	return BoolUint64(!(!(AssignPtrInt32(wc, wchar_t(*(*uint8)(unsafe.Pointer(s)))) != 0)))
+	return BoolUint64(!!(AssignPtrInt32(wc, wchar_t(*(*uint8)(unsafe.Pointer(s)))) != 0))
 __8:
 	;
-	if !((func() int32 {
-		if !(!(int32(*(*uintptr)(unsafe.Pointer(((*__pthread)(unsafe.Pointer(__pthread_self(tls))).locale /* &.cat */)))) != 0)) {
+	if !(func() int32 {
+		if !!(int32(*(*uintptr)(unsafe.Pointer((*__pthread)(unsafe.Pointer(__pthread_self(tls))).locale))) != 0) {
 			return 4
 		}
 		return 1
-	}()) == 1) {
+	}() == 1) {
 		goto __9
 	}
-	*(*wchar_t)(unsafe.Pointer(wc)) = (0xdfff & int32((int8(*(*uint8)(unsafe.Pointer(s))))))
+	*(*wchar_t)(unsafe.Pointer(wc)) = 0xdfff & int32(int8(*(*uint8)(unsafe.Pointer(s))))
 	return 1
 __9:
 	;
-	if !((uint32(*(*uint8)(unsafe.Pointer(s))) - 0xc2) > (0xf4 - 0xc2)) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(s)))-0xc2 > 0xf4-0xc2) {
 		goto __10
 	}
 	goto ilseq
 __10:
 	;
-	c = X__fsmu8[(uint32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&s, 1)))) - 0xc2)]
+	c = X__fsmu8[uint32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&s, 1))))-0xc2]
 	n--
 __7:
 	;
@@ -3466,27 +3466,27 @@ __7:
 	if !(n != 0) {
 		goto __11
 	}
-	if !((((((int32(*(*uint8)(unsafe.Pointer(s)))) >> 3) - 0x10) | (((int32(*(*uint8)(unsafe.Pointer(s)))) >> 3) + ((int32_t(c)) >> 26))) & CplInt32(7)) != 0) {
+	if !((int32(*(*uint8)(unsafe.Pointer(s)))>>3-0x10|(int32(*(*uint8)(unsafe.Pointer(s)))>>3+int32_t(c)>>26))&CplInt32(7) != 0) {
 		goto __12
 	}
 	goto ilseq
 __12:
 	;
 loop:
-	c = ((c << 6) | (uint32(int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&s, 1)))) - 0x80)))
+	c = c<<6 | uint32(int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&s, 1))))-0x80)
 	n--
-	if !(!((c & (uint32(1) << 31)) != 0)) {
+	if !!(c&(uint32(1)<<31) != 0) {
 		goto __13
 	}
 	*(*uint32)(unsafe.Pointer(st)) = uint32(0)
 	*(*wchar_t)(unsafe.Pointer(wc)) = wchar_t(c)
-	return (size_t(N) - n)
+	return size_t(N) - n
 __13:
 	;
 	if !(n != 0) {
 		goto __14
 	}
-	if !((uint32(*(*uint8)(unsafe.Pointer(s))) - 0x80) >= uint32(0x40)) {
+	if !(uint32(*(*uint8)(unsafe.Pointer(s)))-0x80 >= uint32(0x40)) {
 		goto __15
 	}
 	goto ilseq
@@ -3502,14 +3502,14 @@ __11:
 	return Uint64FromInt32(-2)
 ilseq:
 	*(*uint32)(unsafe.Pointer(st)) = uint32(0)
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 84
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 84
 	return Uint64FromInt32(-1)
 }
 
 var _sinternal_state uint32 /* mbrtowc.c:8:18: */
 
 func Xmbsinit(tls *TLS, st uintptr) int32 { /* mbsinit.c:3:5: */
-	return (Bool32(!(st != 0) || !(int32(*(*uint32)(unsafe.Pointer(st))) != 0)))
+	return Bool32(!(st != 0) || !(int32(*(*uint32)(unsafe.Pointer(st))) != 0))
 }
 
 type imaxdiv_t = struct {
@@ -3825,10 +3825,10 @@ __2:
 	goto __3
 __3:
 	;
-	var b uintptr = (p - uintptr((uint64((uintptr(0) /* &.ai */)))))
-	b -= 88 * (uintptr((*aibuf)(unsafe.Pointer(b)).slot))
+	var b uintptr = p - uintptr(uint64(uintptr(0)))
+	b -= 88 * uintptr((*aibuf)(unsafe.Pointer(b)).slot)
 	//TODO LOCK(b->lock);
-	if !(int32(AssignSubPtrInt16(b+82 /* &.ref */, int16(cnt))) != 0) {
+	if !(int32(AssignSubPtrInt16(b+82, int16(cnt))) != 0) {
 		Xfree(tls, b)
 	}
 	//TODO else UNLOCK(b->lock);
@@ -3868,8 +3868,8 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt
 		proto = (*addrinfo)(unsafe.Pointer(hint)).ai_protocol
 		socktype = (*addrinfo)(unsafe.Pointer(hint)).ai_socktype
 
-		var mask int32 = ((((((0x01 | 0x02) | 0x04) | 0x08) | 0x10) | 0x20) | 0x400)
-		if (flags & mask) != flags {
+		var mask int32 = 0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x400
+		if flags&mask != flags {
 			return -1
 		}
 
@@ -3886,7 +3886,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt
 		}
 	}
 
-	if (flags & 0x20) != 0 {
+	if flags&0x20 != 0 {
 		Xabort(tls) //TODO-
 		// 	/* Define the "an address is configured" condition for address
 		// 	 * families via ability to create a socket for the family plus
@@ -3931,26 +3931,26 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt
 		// 	}
 	}
 
-	nservs = X__lookup_serv(tls, bp /* &ports[0] */, serv, proto, socktype, flags)
+	nservs = X__lookup_serv(tls, bp, serv, proto, socktype, flags)
 	if nservs < 0 {
 		return nservs
 	}
 
-	naddrs = X__lookup_name(tls, bp+8 /* &addrs[0] */, bp+1352 /* &canon[0] */, host, family, flags)
+	naddrs = X__lookup_name(tls, bp+8, bp+1352, host, family, flags)
 	if naddrs < 0 {
 		return naddrs
 	}
 
-	nais = (nservs * naddrs)
-	canon_len = int32(Xstrlen(tls, bp+1352 /* &canon[0] */))
-	out = Xcalloc(tls, uint64(1), (((uint64(nais) * uint64(unsafe.Sizeof(aibuf{}))) + uint64(canon_len)) + uint64(1)))
+	nais = nservs * naddrs
+	canon_len = int32(Xstrlen(tls, bp+1352))
+	out = Xcalloc(tls, uint64(1), uint64(nais)*uint64(unsafe.Sizeof(aibuf{}))+uint64(canon_len)+uint64(1))
 	if !(out != 0) {
 		return -10
 	}
 
 	if canon_len != 0 {
-		outcanon = (out + uintptr(nais)*88)
-		Xmemcpy(tls, outcanon, bp+1352 /* &canon[0] */, (uint64(canon_len + 1)))
+		outcanon = out + uintptr(nais)*88
+		Xmemcpy(tls, outcanon, bp+1352, uint64(canon_len+1))
 	} else {
 		outcanon = uintptr(0)
 	}
@@ -3972,31 +3972,31 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt
 			//TODO 		: sizeof(struct sockaddr_in6),
 			//TODO 	.ai_addr = (void *)&out[k].sa,
 			//TODO 	.ai_canonname = outcanon };
-			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_family = (*address)(unsafe.Pointer(bp + 8 /* &addrs */ + uintptr(i)*28)).family
-			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_socktype = int32((*service)(unsafe.Pointer(bp /* &ports */ + uintptr(j)*4)).socktype)
-			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_protocol = int32((*service)(unsafe.Pointer(bp /* &ports */ + uintptr(j)*4)).proto)
+			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_family = (*address)(unsafe.Pointer(bp + 8 + uintptr(i)*28)).family
+			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_socktype = int32((*service)(unsafe.Pointer(bp + uintptr(j)*4)).socktype)
+			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_protocol = int32((*service)(unsafe.Pointer(bp + uintptr(j)*4)).proto)
 			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_addrlen = func() uint32 {
-				if (*address)(unsafe.Pointer(bp+8 /* &addrs */ +uintptr(i)*28)).family == 2 {
+				if (*address)(unsafe.Pointer(bp+8+uintptr(i)*28)).family == 2 {
 					return uint32(unsafe.Sizeof(sockaddr_in{}))
 				}
 				return uint32(unsafe.Sizeof(sockaddr_in6{}))
 			}()
-			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_addr = (out + uintptr(k)*88 + 48 /* &.sa */)
+			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_addr = out + uintptr(k)*88 + 48
 			(*aibuf)(unsafe.Pointer(out + uintptr(k)*88)).ai.ai_canonname = outcanon
 			if k != 0 {
-				(*aibuf)(unsafe.Pointer(out + uintptr((k-1))*88)).ai.ai_next = (out + uintptr(k)*88 /* &.ai */)
+				(*aibuf)(unsafe.Pointer(out + uintptr(k-1)*88)).ai.ai_next = out + uintptr(k)*88
 			}
-			switch (*address)(unsafe.Pointer(bp + 8 /* &addrs */ + uintptr(i)*28)).family {
+			switch (*address)(unsafe.Pointer(bp + 8 + uintptr(i)*28)).family {
 			case 2:
-				(*sockaddr_in)(unsafe.Pointer(out + uintptr(k)*88 + 48 /* &.sa */)).sin_family = sa_family_t(2)
-				(*sockaddr_in)(unsafe.Pointer(out + uintptr(k)*88 + 48 /* &.sa */)).sin_port = Xhtons(tls, (*service)(unsafe.Pointer(bp /* &ports */ +uintptr(j)*4)).port)
-				Xmemcpy(tls, (out + uintptr(k)*88 + 48 /* &.sa */ /* &.sin */ + 4 /* &.sin_addr */), (bp + 8 /* &addrs */ + uintptr(i)*28 + 8 /* &.addr */), uint64(4))
+				(*sockaddr_in)(unsafe.Pointer(out + uintptr(k)*88 + 48)).sin_family = sa_family_t(2)
+				(*sockaddr_in)(unsafe.Pointer(out + uintptr(k)*88 + 48)).sin_port = Xhtons(tls, (*service)(unsafe.Pointer(bp+uintptr(j)*4)).port)
+				Xmemcpy(tls, out+uintptr(k)*88+48+4, bp+8+uintptr(i)*28+8, uint64(4))
 				break
 			case 10:
-				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48 /* &.sa */)).sin6_family = sa_family_t(10)
-				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48 /* &.sa */)).sin6_port = Xhtons(tls, (*service)(unsafe.Pointer(bp /* &ports */ +uintptr(j)*4)).port)
-				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48 /* &.sa */)).sin6_scope_id = (*address)(unsafe.Pointer(bp + 8 /* &addrs */ + uintptr(i)*28)).scopeid
-				Xmemcpy(tls, (out + uintptr(k)*88 + 48 /* &.sa */ /* &.sin6 */ + 8 /* &.sin6_addr */), (bp + 8 /* &addrs */ + uintptr(i)*28 + 8 /* &.addr */), uint64(16))
+				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48)).sin6_family = sa_family_t(10)
+				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48)).sin6_port = Xhtons(tls, (*service)(unsafe.Pointer(bp+uintptr(j)*4)).port)
+				(*sockaddr_in6)(unsafe.Pointer(out + uintptr(k)*88 + 48)).sin6_scope_id = (*address)(unsafe.Pointer(bp + 8 + uintptr(i)*28)).scopeid
+				Xmemcpy(tls, out+uintptr(k)*88+48+8, bp+8+uintptr(i)*28+8, uint64(16))
 				break
 			}
 
@@ -4010,7 +4010,7 @@ func Xgetaddrinfo(tls *TLS, host uintptr, serv uintptr, hint uintptr, res uintpt
 	__3:
 	}
 	(*aibuf)(unsafe.Pointer(out)).ref = int16(nais)
-	*(*uintptr)(unsafe.Pointer(res)) = (out /* &.ai */)
+	*(*uintptr)(unsafe.Pointer(res)) = out
 	return 0
 }
 
@@ -4046,15 +4046,15 @@ func Xgethostbyaddr(tls *TLS, a uintptr, l socklen_t, af int32) uintptr { /* get
 	// var res uintptr at bp, 8
 
 	var err int32
-	for ok := true; ok; ok = (err == 34) {
+	for ok := true; ok; ok = err == 34 {
 		Xfree(tls, _sh)
-		_sh = Xmalloc(tls, AssignAddUint64(&size, (size+uint64(1))))
+		_sh = Xmalloc(tls, AssignAddUint64(&size, size+uint64(1)))
 		if !(_sh != 0) {
-			(*(*int32)(unsafe.Pointer(X__h_errno_location(tls)))) = 3
+			*(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = 3
 			return uintptr(0)
 		}
 		err = Xgethostbyaddr_r(tls, a, l, af, _sh,
-			(_sh + uintptr(1)*32), (size - size_t(unsafe.Sizeof(hostent{}))), bp /* &res */, X__h_errno_location(tls))
+			_sh+uintptr(1)*32, size-size_t(unsafe.Sizeof(hostent{})), bp, X__h_errno_location(tls))
 	}
 	if err != 0 {
 		return uintptr(0)
@@ -4075,11 +4075,11 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l socklen_t, af int32, h uintptr, buf
 	*(*struct {
 		sin sockaddr_in
 		_   [12]byte
-	})(unsafe.Pointer(bp /* sa1 */)) = struct {
+	})(unsafe.Pointer(bp)) = struct {
 		sin sockaddr_in
 		_   [12]byte
 	}{} //TODO-
-	(*sockaddr_in)(unsafe.Pointer(bp /* &sa1 */)).sin_family = sa_family_t(af) //TODO-
+	(*sockaddr_in)(unsafe.Pointer(bp)).sin_family = sa_family_t(af) //TODO-
 	var sl socklen_t
 	if af == 10 {
 		sl = uint32(unsafe.Sizeof(sockaddr_in6{}))
@@ -4091,30 +4091,30 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l socklen_t, af int32, h uintptr, buf
 	*(*uintptr)(unsafe.Pointer(res)) = uintptr(0)
 
 	// Load address argument into sockaddr structure
-	if (af == 10) && (l == socklen_t(16)) {
-		Xmemcpy(tls, (bp /* &sa1 */ /* &.sin6 */ + 8 /* &.sin6_addr */), a, uint64(16))
-	} else if (af == 2) && (l == socklen_t(4)) {
-		Xmemcpy(tls, (bp /* &sa1 */ /* &.sin */ + 4 /* &.sin_addr */), a, uint64(4))
+	if af == 10 && l == socklen_t(16) {
+		Xmemcpy(tls, bp+8, a, uint64(16))
+	} else if af == 2 && l == socklen_t(4) {
+		Xmemcpy(tls, bp+4, a, uint64(4))
 	} else {
 		*(*int32)(unsafe.Pointer(err)) = 3
 		return 22
 	}
 
 	// Align buffer and check for space for pointers and ip address
-	i = (int32(uintptr_t(buf) & (uint64(unsafe.Sizeof(uintptr(0))) - uint64(1))))
+	i = int32(uintptr_t(buf) & (uint64(unsafe.Sizeof(uintptr(0))) - uint64(1)))
 	if !(i != 0) {
 		i = int32(unsafe.Sizeof(uintptr(0)))
 	}
-	if buflen <= (((uint64(5) * uint64(unsafe.Sizeof(uintptr(0)))) - uint64(i)) + uint64(l)) {
+	if buflen <= uint64(5)*uint64(unsafe.Sizeof(uintptr(0)))-uint64(i)+uint64(l) {
 		return 34
 	}
-	buf += (uintptr(uint64(unsafe.Sizeof(uintptr(0))) - uint64(i)))
-	buflen = buflen - (((uint64(5) * uint64(unsafe.Sizeof(uintptr(0)))) - uint64(i)) + uint64(l))
+	buf += uintptr(uint64(unsafe.Sizeof(uintptr(0))) - uint64(i))
+	buflen = buflen - (uint64(5)*uint64(unsafe.Sizeof(uintptr(0))) - uint64(i) + uint64(l))
 
 	(*hostent)(unsafe.Pointer(h)).h_addr_list = buf
-	buf += (uintptr(uint64(2) * uint64(unsafe.Sizeof(uintptr(0)))))
+	buf += uintptr(uint64(2) * uint64(unsafe.Sizeof(uintptr(0))))
 	(*hostent)(unsafe.Pointer(h)).h_aliases = buf
-	buf += (uintptr(uint64(2) * uint64(unsafe.Sizeof(uintptr(0)))))
+	buf += uintptr(uint64(2) * uint64(unsafe.Sizeof(uintptr(0))))
 
 	*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list)) = buf
 	Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list)), a, uint64(l))
@@ -4123,7 +4123,7 @@ func Xgethostbyaddr_r(tls *TLS, a uintptr, l socklen_t, af int32, h uintptr, buf
 	*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases)) = buf
 	*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8)) = uintptr(0)
 
-	switch Xgetnameinfo(tls, bp /* &sa1 */, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) {
+	switch Xgetnameinfo(tls, bp, sl, buf, uint32(buflen), uintptr(0), uint32(0), 0) {
 	case -3:
 		*(*int32)(unsafe.Pointer(err)) = 2
 		return 11
@@ -4161,15 +4161,15 @@ func Xgethostbyname2(tls *TLS, name uintptr, af int32) uintptr { /* gethostbynam
 	// var res uintptr at bp, 8
 
 	var err int32
-	for ok := true; ok; ok = (err == 34) {
+	for ok := true; ok; ok = err == 34 {
 		Xfree(tls, _sh1)
-		_sh1 = Xmalloc(tls, AssignAddUint64(&size, (size+uint64(1))))
+		_sh1 = Xmalloc(tls, AssignAddUint64(&size, size+uint64(1)))
 		if !(_sh1 != 0) {
-			(*(*int32)(unsafe.Pointer(X__h_errno_location(tls)))) = 3
+			*(*int32)(unsafe.Pointer(X__h_errno_location(tls))) = 3
 			return uintptr(0)
 		}
 		err = Xgethostbyname2_r(tls, name, af, _sh1,
-			(_sh1 + uintptr(1)*32), (size - size_t(unsafe.Sizeof(hostent{}))), bp /* &res */, X__h_errno_location(tls))
+			_sh1+uintptr(1)*32, size-size_t(unsafe.Sizeof(hostent{})), bp, X__h_errno_location(tls))
 	}
 	if err != 0 {
 		return uintptr(0)
@@ -4193,7 +4193,7 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr,
 	var need size_t
 
 	*(*uintptr)(unsafe.Pointer(res)) = uintptr(0)
-	cnt = X__lookup_name(tls, bp /* &addrs[0] */, bp+1344 /* &canon[0] */, name, af, 0x02)
+	cnt = X__lookup_name(tls, bp, bp+1344, name, af, 0x02)
 	if cnt < 0 {
 		switch cnt {
 		case -2:
@@ -4227,13 +4227,13 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr,
 	}()
 
 	// Align buffer
-	align = (-uintptr_t(buf) & (uint64(unsafe.Sizeof(uintptr(0))) - uint64(1)))
+	align = -uintptr_t(buf) & (uint64(unsafe.Sizeof(uintptr(0))) - uint64(1))
 
-	need = (uint64(4) * uint64(unsafe.Sizeof(uintptr(0))))
-	need = need + ((uint64(cnt + 1)) * (uint64(unsafe.Sizeof(uintptr(0))) + uint64((*hostent)(unsafe.Pointer(h)).h_length)))
+	need = uint64(4) * uint64(unsafe.Sizeof(uintptr(0)))
+	need = need + uint64(cnt+1)*(uint64(unsafe.Sizeof(uintptr(0)))+uint64((*hostent)(unsafe.Pointer(h)).h_length))
 	need = need + (Xstrlen(tls, name) + uint64(1))
-	need = need + (Xstrlen(tls, bp+1344 /* &canon[0] */) + uint64(1))
-	need = need + (align)
+	need = need + (Xstrlen(tls, bp+1344) + uint64(1))
+	need = need + align
 
 	if need > buflen {
 		return 34
@@ -4241,25 +4241,25 @@ func Xgethostbyname2_r(tls *TLS, name uintptr, af int32, h uintptr, buf uintptr,
 
 	buf += uintptr(align)
 	(*hostent)(unsafe.Pointer(h)).h_aliases = buf
-	buf += (uintptr(uint64(3) * uint64(unsafe.Sizeof(uintptr(0)))))
+	buf += uintptr(uint64(3) * uint64(unsafe.Sizeof(uintptr(0))))
 	(*hostent)(unsafe.Pointer(h)).h_addr_list = buf
-	buf += (uintptr((uint64(cnt + 1)) * uint64(unsafe.Sizeof(uintptr(0)))))
+	buf += uintptr(uint64(cnt+1) * uint64(unsafe.Sizeof(uintptr(0))))
 
 	for i = 0; i < cnt; i++ {
 		*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list + uintptr(i)*8)) = buf
 		buf += uintptr((*hostent)(unsafe.Pointer(h)).h_length)
-		Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list + uintptr(i)*8)), bp /* &addrs */ +uintptr(i)*28+8 /* &.addr */, uint64((*hostent)(unsafe.Pointer(h)).h_length))
+		Xmemcpy(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list + uintptr(i)*8)), bp+uintptr(i)*28+8, uint64((*hostent)(unsafe.Pointer(h)).h_length))
 	}
 	*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_addr_list + uintptr(i)*8)) = uintptr(0)
 
 	(*hostent)(unsafe.Pointer(h)).h_name = AssignPtrUintptr((*hostent)(unsafe.Pointer(h)).h_aliases, buf)
-	Xstrcpy(tls, (*hostent)(unsafe.Pointer(h)).h_name, bp+1344 /* &canon[0] */)
-	buf += (uintptr(Xstrlen(tls, (*hostent)(unsafe.Pointer(h)).h_name) + uint64(1)))
+	Xstrcpy(tls, (*hostent)(unsafe.Pointer(h)).h_name, bp+1344)
+	buf += uintptr(Xstrlen(tls, (*hostent)(unsafe.Pointer(h)).h_name) + uint64(1))
 
 	if Xstrcmp(tls, (*hostent)(unsafe.Pointer(h)).h_name, name) != 0 {
 		*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8)) = buf
 		Xstrcpy(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8)), name)
-		buf += (uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8))) + uint64(1)))
+		buf += uintptr(Xstrlen(tls, *(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8))) + uint64(1))
 	} else {
 		*(*uintptr)(unsafe.Pointer((*hostent)(unsafe.Pointer(h)).h_aliases + 1*8)) = uintptr(0)
 	}
@@ -4452,11 +4452,11 @@ type res_sym = struct {
 } /* resolv.h:70:1 */
 
 func itoa(tls *TLS, p uintptr, x uint32) uintptr { /* getnameinfo.c:18:13: */
-	p += (uintptr(uint64(3) * uint64(unsafe.Sizeof(int32(0)))))
+	p += uintptr(uint64(3) * uint64(unsafe.Sizeof(int32(0))))
 	*(*int8)(unsafe.Pointer(PreDecUintptr(&p, 1))) = int8(0)
 	for ok := true; ok; ok = x != 0 {
-		*(*int8)(unsafe.Pointer(PreDecUintptr(&p, 1))) = (int8(uint32('0') + (x % uint32(10))))
-		x = x / (uint32(10))
+		*(*int8)(unsafe.Pointer(PreDecUintptr(&p, 1))) = int8(uint32('0') + x%uint32(10))
+		x = x / uint32(10)
 	}
 	return p
 }
@@ -4465,22 +4465,22 @@ func mkptr4(tls *TLS, s uintptr, ip uintptr) { /* getnameinfo.c:28:13: */
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 
-	Xsprintf(tls, s, ts+25, /* "%d.%d.%d.%d.in-a..." */
+	Xsprintf(tls, s, ts+25,
 		VaList(bp, int32(*(*uint8)(unsafe.Pointer(ip + 3))), int32(*(*uint8)(unsafe.Pointer(ip + 2))), int32(*(*uint8)(unsafe.Pointer(ip + 1))), int32(*(*uint8)(unsafe.Pointer(ip)))))
 }
 
 func mkptr6(tls *TLS, s uintptr, ip uintptr) { /* getnameinfo.c:34:13: */
 	var i int32
 	for i = 15; i >= 0; i-- {
-		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = _sxdigits[(int32(*(*uint8)(unsafe.Pointer(ip + uintptr(i)))) & 15)]
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = _sxdigits[int32(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))&15]
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8('.')
-		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = _sxdigits[(int32(*(*uint8)(unsafe.Pointer(ip + uintptr(i)))) >> 4)]
+		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = _sxdigits[int32(*(*uint8)(unsafe.Pointer(ip + uintptr(i))))>>4]
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1))) = int8('.')
 	}
-	Xstrcpy(tls, s, ts+50 /* "ip6.arpa" */)
+	Xstrcpy(tls, s, ts+50)
 }
 
-var _sxdigits = *(*[17]int8)(unsafe.Pointer(ts + 59 /* "0123456789abcdef" */)) /* getnameinfo.c:36:20 */
+var _sxdigits = *(*[17]int8)(unsafe.Pointer(ts + 59)) /* getnameinfo.c:36:20 */
 
 func reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int32) { /* getnameinfo.c:45:13: */
 	bp := tls.Alloc(556)
@@ -4497,45 +4497,45 @@ func reverse_hosts(tls *TLS, buf uintptr, a uintptr, scopeid uint32, family int3
 	// var iplit address at bp+528, 28
 
 	//TODO FILE _f, *f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
-	var f uintptr = Xfopen(tls, ts+76 /* "/etc/hosts" */, ts+87 /* "rb" */)
+	var f uintptr = Xfopen(tls, ts+76, ts+87)
 	if !(f != 0) {
 		return
 	}
 	if family == 2 {
-		Xmemcpy(tls, (bp /* &atmp[0] */ + uintptr(12)), a, uint64(4))
-		Xmemcpy(tls, bp /* &atmp[0] */, ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12))
+		Xmemcpy(tls, bp+uintptr(12), a, uint64(4))
+		Xmemcpy(tls, bp, ts+90, uint64(12))
 		a = bp /* &atmp[0] */
 	}
-	for Xfgets(tls, bp+16 /* &line[0] */, int32(unsafe.Sizeof([512]int8{})), f) != 0 {
-		if AssignUintptr(&p, Xstrchr(tls, bp+16 /* &line[0] */, '#')) != 0 {
+	for Xfgets(tls, bp+16, int32(unsafe.Sizeof([512]int8{})), f) != 0 {
+		if AssignUintptr(&p, Xstrchr(tls, bp+16, '#')) != 0 {
 			*(*int8)(unsafe.Pointer(PostIncUintptr(&p, 1))) = int8('\n')
 			*(*int8)(unsafe.Pointer(p)) = int8(0)
 		}
 
-		for p = bp + 16; /* &line[0] */ (*(*int8)(unsafe.Pointer(p)) != 0) && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
+		for p = bp + 16; /* &line[0] */ *(*int8)(unsafe.Pointer(p)) != 0 && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
 		}
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&p, 1))) = int8(0)
-		if X__lookup_ipliteral(tls, bp+528 /* &iplit */, bp+16 /* &line[0] */, 0) <= 0 {
+		if X__lookup_ipliteral(tls, bp+528, bp+16, 0) <= 0 {
 			continue
 		}
 
-		if (*address)(unsafe.Pointer(bp+528 /* &iplit */)).family == 2 {
-			Xmemcpy(tls, ((bp + 528 /* &iplit */ + 8 /* &.addr */) + uintptr(12)), bp+528 /* &iplit */ +8 /* &.addr */, uint64(4))
-			Xmemcpy(tls, bp+528 /* &iplit */ +8 /* &.addr */, ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12))
+		if (*address)(unsafe.Pointer(bp+528)).family == 2 {
+			Xmemcpy(tls, bp+528+8+uintptr(12), bp+528+8, uint64(4))
+			Xmemcpy(tls, bp+528+8, ts+90, uint64(12))
 			(*address)(unsafe.Pointer(bp + 528 /* &iplit */)).scopeid = uint32(0)
 		}
 
-		if (Xmemcmp(tls, a, bp+528 /* &iplit */ +8 /* &.addr */, uint64(16)) != 0) || ((*address)(unsafe.Pointer(bp+528 /* &iplit */)).scopeid != scopeid) {
+		if Xmemcmp(tls, a, bp+528+8, uint64(16)) != 0 || (*address)(unsafe.Pointer(bp+528)).scopeid != scopeid {
 			continue
 		}
 
-		for ; (*(*int8)(unsafe.Pointer(p)) != 0) && (__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
+		for ; *(*int8)(unsafe.Pointer(p)) != 0 && __isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0; p++ {
 		}
-		for z = p; (*(*int8)(unsafe.Pointer(z)) != 0) && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(z)))) != 0); z++ {
+		for z = p; *(*int8)(unsafe.Pointer(z)) != 0 && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(z)))) != 0); z++ {
 		}
 		*(*int8)(unsafe.Pointer(z)) = int8(0)
-		if ((int64(z) - int64(p)) / 1) < int64(256) {
-			Xmemcpy(tls, buf, p, (uint64(((int64(z) - int64(p)) / 1) + int64(1))))
+		if (int64(z)-int64(p))/1 < int64(256) {
+			Xmemcpy(tls, buf, p, uint64((int64(z)-int64(p))/1+int64(1)))
 			break
 		}
 	}
@@ -4585,22 +4585,22 @@ func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen soc
 
 	switch af {
 	case 2:
-		a = (sa1 + 4 /* &.sin_addr */)
-		if (uint64(sl) < uint64(unsafe.Sizeof(sockaddr_in{}))) {
+		a = sa1 + 4
+		if uint64(sl) < uint64(unsafe.Sizeof(sockaddr_in{})) {
 			return -6
 		}
-		mkptr4(tls, bp /* &ptr[0] */, a)
+		mkptr4(tls, bp, a)
 		scopeid = uint32(0)
 		break
 	case 10:
-		a = (sa1 + 8 /* &.sin6_addr */)
-		if (uint64(sl) < uint64(unsafe.Sizeof(sockaddr_in6{}))) {
+		a = sa1 + 8
+		if uint64(sl) < uint64(unsafe.Sizeof(sockaddr_in6{})) {
 			return -6
 		}
-		if Xmemcmp(tls, a, ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12)) != 0 {
-			mkptr6(tls, bp /* &ptr[0] */, a)
+		if Xmemcmp(tls, a, ts+90, uint64(12)) != 0 {
+			mkptr6(tls, bp, a)
 		} else {
-			mkptr4(tls, bp /* &ptr[0] */, (a + uintptr(12)))
+			mkptr4(tls, bp, a+uintptr(12))
 		}
 		scopeid = (*sockaddr_in6)(unsafe.Pointer(sa1)).sin6_scope_id
 		break
@@ -4608,12 +4608,12 @@ func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen soc
 		return -6
 	}
 
-	if (node != 0) && (nodelen != 0) {
-		*(*int8)(unsafe.Pointer(bp + 78 /* &buf[0] */)) = int8(0)
-		if !((flags & 0x01) != 0) {
-			reverse_hosts(tls, bp+78 /* &buf[0] */, a, scopeid, af)
+	if node != 0 && nodelen != 0 {
+		*(*int8)(unsafe.Pointer(bp + 78)) = int8(0)
+		if !(flags&0x01 != 0) {
+			reverse_hosts(tls, bp+78, a, scopeid, af)
 		}
-		if !(int32(*(*int8)(unsafe.Pointer(bp + 78 /* buf */))) != 0) && !((flags & 0x01) != 0) {
+		if !(int32(*(*int8)(unsafe.Pointer(bp + 78))) != 0) && !(flags&0x01 != 0) {
 			Xabort(tls) //TODO-
 			// unsigned char query[18+PTR_MAX], reply[512];
 			// int qlen = __res_mkquery(0, ptr, 1, RR_PTR,
@@ -4624,11 +4624,11 @@ func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen soc
 			// if (rlen > 0)
 			// 	__dns_parse(reply, rlen, dns_parse_callback, buf);
 		}
-		if !(int32(*(*int8)(unsafe.Pointer(bp + 78 /* buf */))) != 0) {
-			if (flags & 0x08) != 0 {
+		if !(int32(*(*int8)(unsafe.Pointer(bp + 78))) != 0) {
+			if flags&0x08 != 0 {
 				return -2
 			}
-			Xinet_ntop(tls, af, a, bp+78 /* &buf[0] */, uint32(unsafe.Sizeof([256]int8{})))
+			Xinet_ntop(tls, af, a, bp+78, uint32(unsafe.Sizeof([256]int8{})))
 			if scopeid != 0 {
 				Xabort(tls) //TODO-
 				// char *p = 0, tmp[IF_NAMESIZE+1];
@@ -4642,21 +4642,21 @@ func Xgetnameinfo(tls *TLS, sa1 uintptr, sl socklen_t, node uintptr, nodelen soc
 				// strcat(buf, p);
 			}
 		}
-		if Xstrlen(tls, bp+78 /* &buf[0] */) >= size_t(nodelen) {
+		if Xstrlen(tls, bp+78) >= size_t(nodelen) {
 			return -12
 		}
-		Xstrcpy(tls, node, bp+78 /* &buf[0] */)
+		Xstrcpy(tls, node, bp+78)
 	}
 
-	if (serv != 0) && (servlen != 0) {
+	if serv != 0 && servlen != 0 {
 		var p uintptr = bp + 78 /* buf */
 		var port int32 = int32(Xntohs(tls, (*sockaddr_in)(unsafe.Pointer(sa1)).sin_port))
-		*(*int8)(unsafe.Pointer(bp + 78 /* &buf[0] */)) = int8(0)
-		if !((flags & 0x02) != 0) {
-			reverse_services(tls, bp+78 /* &buf[0] */, port, (flags & 0x10))
+		*(*int8)(unsafe.Pointer(bp + 78)) = int8(0)
+		if !(flags&0x02 != 0) {
+			reverse_services(tls, bp+78, port, flags&0x10)
 		}
 		if !(int32(*(*int8)(unsafe.Pointer(p))) != 0) {
-			p = itoa(tls, bp+334 /* &num[0] */, uint32(port))
+			p = itoa(tls, bp+334, uint32(port))
 		}
 		if Xstrlen(tls, p) >= size_t(servlen) {
 			return -12
@@ -4685,41 +4685,41 @@ func X__inet_aton(tls *TLS, s0 uintptr, dest uintptr) int32 { /* inet_aton.c:7:5
 	var i int32
 
 	for i = 0; i < 4; i++ {
-		*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + uintptr(i)*8)) = Xstrtoul(tls, s, bp+32 /* &z */, 0)
-		if ((*(*uintptr)(unsafe.Pointer(bp + 32 /* z */)) == s) || ((*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32 /* z */)))) != 0) && (int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32 /* z */))))) != '.'))) || !(func() int32 {
+		*(*uint64)(unsafe.Pointer(bp + uintptr(i)*8)) = Xstrtoul(tls, s, bp+32, 0)
+		if *(*uintptr)(unsafe.Pointer(bp + 32)) == s || *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32)))) != 0 && int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != '.' || !(func() int32 {
 			if 0 != 0 {
 				return Xisdigit(tls, int32(*(*int8)(unsafe.Pointer(s))))
 			}
-			return (Bool32(((uint32(*(*int8)(unsafe.Pointer(s)))) - uint32('0')) < uint32(10)))
+			return Bool32(uint32(*(*int8)(unsafe.Pointer(s)))-uint32('0') < uint32(10))
 		}() != 0) {
 			return 0
 		}
-		if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32 /* z */))))) != 0) {
+		if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 32))))) != 0) {
 			break
 		}
-		s = (*(*uintptr)(unsafe.Pointer(bp + 32 /* z */)) + uintptr(1))
+		s = *(*uintptr)(unsafe.Pointer(bp + 32)) + uintptr(1)
 	}
 	if i == 4 {
 		return 0
 	}
 	switch i {
 	case 0:
-		*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + 1*8)) = (*(*uint64)(unsafe.Pointer(bp /* &a[0] */)) & uint64(0xffffff))
-		AssignShrPtrUint64(bp /* &a */, int(24))
+		*(*uint64)(unsafe.Pointer(bp + 1*8)) = *(*uint64)(unsafe.Pointer(bp)) & uint64(0xffffff)
+		AssignShrPtrUint64(bp, int(24))
 		fallthrough
 	case 1:
-		*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + 2*8)) = (*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + 1*8)) & uint64(0xffff))
-		AssignShrPtrUint64(bp /* &a */ +1*8, int(16))
+		*(*uint64)(unsafe.Pointer(bp + 2*8)) = *(*uint64)(unsafe.Pointer(bp + 1*8)) & uint64(0xffff)
+		AssignShrPtrUint64(bp+1*8, int(16))
 		fallthrough
 	case 2:
-		*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + 3*8)) = (*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + 2*8)) & uint64(0xff))
-		AssignShrPtrUint64(bp /* &a */ +2*8, int(8))
+		*(*uint64)(unsafe.Pointer(bp + 3*8)) = *(*uint64)(unsafe.Pointer(bp + 2*8)) & uint64(0xff)
+		AssignShrPtrUint64(bp+2*8, int(8))
 	}
 	for i = 0; i < 4; i++ {
-		if *(*uint64)(unsafe.Pointer(bp /* &a[0] */ + uintptr(i)*8)) > uint64(255) {
+		if *(*uint64)(unsafe.Pointer(bp + uintptr(i)*8)) > uint64(255) {
 			return 0
 		}
-		*(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8(*(*uint64)(unsafe.Pointer(bp /* &a[0] */ + uintptr(i)*8)))
+		*(*uint8)(unsafe.Pointer(d + uintptr(i))) = uint8(*(*uint64)(unsafe.Pointer(bp + uintptr(i)*8)))
 	}
 	return 1
 }
@@ -4737,63 +4737,63 @@ func Xinet_ntop(tls *TLS, af int32, a0 uintptr, s uintptr, l socklen_t) uintptr
 
 	switch af {
 	case 2:
-		if socklen_t(Xsnprintf(tls, s, uint64(l), ts+103 /* "%d.%d.%d.%d" */, VaList(bp, int32(*(*uint8)(unsafe.Pointer(a))), int32(*(*uint8)(unsafe.Pointer(a + 1))), int32(*(*uint8)(unsafe.Pointer(a + 2))), int32(*(*uint8)(unsafe.Pointer(a + 3)))))) < l {
+		if socklen_t(Xsnprintf(tls, s, uint64(l), ts+103, VaList(bp, int32(*(*uint8)(unsafe.Pointer(a))), int32(*(*uint8)(unsafe.Pointer(a + 1))), int32(*(*uint8)(unsafe.Pointer(a + 2))), int32(*(*uint8)(unsafe.Pointer(a + 3)))))) < l {
 			return s
 		}
 		break
 	case 10:
-		if Xmemcmp(tls, a, ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12)) != 0 {
-			Xsnprintf(tls, bp+176 /* &buf[0] */, uint64(unsafe.Sizeof([100]int8{})),
-				ts+115, /* "%x:%x:%x:%x:%x:%..." */
-				VaList(bp+32, ((256*int32(*(*uint8)(unsafe.Pointer(a))))+int32(*(*uint8)(unsafe.Pointer(a + 1)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 2))))+int32(*(*uint8)(unsafe.Pointer(a + 3)))),
-					((256*int32(*(*uint8)(unsafe.Pointer(a + 4))))+int32(*(*uint8)(unsafe.Pointer(a + 5)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 6))))+int32(*(*uint8)(unsafe.Pointer(a + 7)))),
-					((256*int32(*(*uint8)(unsafe.Pointer(a + 8))))+int32(*(*uint8)(unsafe.Pointer(a + 9)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 10))))+int32(*(*uint8)(unsafe.Pointer(a + 11)))),
-					((256*int32(*(*uint8)(unsafe.Pointer(a + 12))))+int32(*(*uint8)(unsafe.Pointer(a + 13)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 14))))+int32(*(*uint8)(unsafe.Pointer(a + 15))))))
+		if Xmemcmp(tls, a, ts+90, uint64(12)) != 0 {
+			Xsnprintf(tls, bp+176, uint64(unsafe.Sizeof([100]int8{})),
+				ts+115,
+				VaList(bp+32, 256*int32(*(*uint8)(unsafe.Pointer(a)))+int32(*(*uint8)(unsafe.Pointer(a + 1))), 256*int32(*(*uint8)(unsafe.Pointer(a + 2)))+int32(*(*uint8)(unsafe.Pointer(a + 3))),
+					256*int32(*(*uint8)(unsafe.Pointer(a + 4)))+int32(*(*uint8)(unsafe.Pointer(a + 5))), 256*int32(*(*uint8)(unsafe.Pointer(a + 6)))+int32(*(*uint8)(unsafe.Pointer(a + 7))),
+					256*int32(*(*uint8)(unsafe.Pointer(a + 8)))+int32(*(*uint8)(unsafe.Pointer(a + 9))), 256*int32(*(*uint8)(unsafe.Pointer(a + 10)))+int32(*(*uint8)(unsafe.Pointer(a + 11))),
+					256*int32(*(*uint8)(unsafe.Pointer(a + 12)))+int32(*(*uint8)(unsafe.Pointer(a + 13))), 256*int32(*(*uint8)(unsafe.Pointer(a + 14)))+int32(*(*uint8)(unsafe.Pointer(a + 15)))))
 		} else {
-			Xsnprintf(tls, bp+176 /* &buf[0] */, uint64(unsafe.Sizeof([100]int8{})),
-				ts+139, /* "%x:%x:%x:%x:%x:%..." */
-				VaList(bp+96, ((256*int32(*(*uint8)(unsafe.Pointer(a))))+int32(*(*uint8)(unsafe.Pointer(a + 1)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 2))))+int32(*(*uint8)(unsafe.Pointer(a + 3)))),
-					((256*int32(*(*uint8)(unsafe.Pointer(a + 4))))+int32(*(*uint8)(unsafe.Pointer(a + 5)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 6))))+int32(*(*uint8)(unsafe.Pointer(a + 7)))),
-					((256*int32(*(*uint8)(unsafe.Pointer(a + 8))))+int32(*(*uint8)(unsafe.Pointer(a + 9)))), ((256*int32(*(*uint8)(unsafe.Pointer(a + 10))))+int32(*(*uint8)(unsafe.Pointer(a + 11)))),
+			Xsnprintf(tls, bp+176, uint64(unsafe.Sizeof([100]int8{})),
+				ts+139,
+				VaList(bp+96, 256*int32(*(*uint8)(unsafe.Pointer(a)))+int32(*(*uint8)(unsafe.Pointer(a + 1))), 256*int32(*(*uint8)(unsafe.Pointer(a + 2)))+int32(*(*uint8)(unsafe.Pointer(a + 3))),
+					256*int32(*(*uint8)(unsafe.Pointer(a + 4)))+int32(*(*uint8)(unsafe.Pointer(a + 5))), 256*int32(*(*uint8)(unsafe.Pointer(a + 6)))+int32(*(*uint8)(unsafe.Pointer(a + 7))),
+					256*int32(*(*uint8)(unsafe.Pointer(a + 8)))+int32(*(*uint8)(unsafe.Pointer(a + 9))), 256*int32(*(*uint8)(unsafe.Pointer(a + 10)))+int32(*(*uint8)(unsafe.Pointer(a + 11))),
 					int32(*(*uint8)(unsafe.Pointer(a + 12))), int32(*(*uint8)(unsafe.Pointer(a + 13))), int32(*(*uint8)(unsafe.Pointer(a + 14))), int32(*(*uint8)(unsafe.Pointer(a + 15)))))
 		}
 		// Replace longest /(^0|:)[:0]{2,}/ with "::"
 		i = AssignInt32(&best, 0)
 		max = 2
-		for ; *(*int8)(unsafe.Pointer(bp + 176 /* &buf[0] */ + uintptr(i))) != 0; i++ {
-			if (i != 0) && (int32(*(*int8)(unsafe.Pointer(bp + 176 /* &buf[0] */ + uintptr(i)))) != ':') {
+		for ; *(*int8)(unsafe.Pointer(bp + 176 + uintptr(i))) != 0; i++ {
+			if i != 0 && int32(*(*int8)(unsafe.Pointer(bp + 176 + uintptr(i)))) != ':' {
 				continue
 			}
-			j = int32(Xstrspn(tls, (bp + 176 /* &buf[0] */ + uintptr(i)), ts+169 /* ":0" */))
+			j = int32(Xstrspn(tls, bp+176+uintptr(i), ts+169))
 			if j > max {
 				best = i
 				max = j
 			}
 		}
 		if max > 3 {
-			*(*int8)(unsafe.Pointer(bp + 176 /* &buf[0] */ + uintptr(best))) = AssignPtrInt8(bp+176 /* &buf */ +uintptr((best+1)), int8(':'))
-			Xmemmove(tls, ((bp + 176 /* &buf[0] */ + uintptr(best)) + uintptr(2)), ((bp + 176 /* &buf[0] */ + uintptr(best)) + uintptr(max)), (uint64(((i - best) - max) + 1)))
+			*(*int8)(unsafe.Pointer(bp + 176 + uintptr(best))) = AssignPtrInt8(bp+176+uintptr(best+1), int8(':'))
+			Xmemmove(tls, bp+176+uintptr(best)+uintptr(2), bp+176+uintptr(best)+uintptr(max), uint64(i-best-max+1))
 		}
-		if Xstrlen(tls, bp+176 /* &buf[0] */) < size_t(l) {
-			Xstrcpy(tls, s, bp+176 /* &buf[0] */)
+		if Xstrlen(tls, bp+176) < size_t(l) {
+			Xstrcpy(tls, s, bp+176)
 			return s
 		}
 		break
 	default:
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 97
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 97
 		return uintptr(0)
 	}
-	(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 28
+	*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 28
 	return uintptr(0)
 }
 
 func hexval(tls *TLS, c uint32) int32 { /* inet_pton.c:7:12: */
-	if (c - uint32('0')) < uint32(10) {
-		return (int32(c - uint32('0')))
+	if c-uint32('0') < uint32(10) {
+		return int32(c - uint32('0'))
 	}
-	c = c | (uint32(32))
-	if (c - uint32('a')) < uint32(6) {
-		return (int32((c - uint32('a')) + uint32(10)))
+	c = c | uint32(32)
+	if c-uint32('a') < uint32(6) {
+		return int32(c - uint32('a') + uint32(10))
 	}
 	return -1
 }
@@ -4814,40 +4814,40 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) int32 { /* inet_pton.
 
 	if af == 2 {
 		for i = 0; i < 4; i++ {
-			for v = AssignInt32(&j, 0); (j < 3) && (func() int32 {
+			for v = AssignInt32(&j, 0); j < 3 && func() int32 {
 				if 0 != 0 {
 					return Xisdigit(tls, int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))))
 				}
-				return (Bool32(((uint32(*(*int8)(unsafe.Pointer(s + uintptr(j))))) - uint32('0')) < uint32(10)))
-			}() != 0); j++ {
-				v = (((10 * v) + int32(*(*int8)(unsafe.Pointer(s + uintptr(j))))) - '0')
+				return Bool32(uint32(*(*int8)(unsafe.Pointer(s + uintptr(j))))-uint32('0') < uint32(10))
+			}() != 0; j++ {
+				v = 10*v + int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) - '0'
 			}
-			if ((j == 0) || ((j > 1) && (int32(*(*int8)(unsafe.Pointer(s))) == '0'))) || (v > 255) {
+			if j == 0 || j > 1 && int32(*(*int8)(unsafe.Pointer(s))) == '0' || v > 255 {
 				return 0
 			}
 			*(*uint8)(unsafe.Pointer(a + uintptr(i))) = uint8(v)
-			if (int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) == 0) && (i == 3) {
+			if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) == 0 && i == 3 {
 				return 1
 			}
 			if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != '.' {
 				return 0
 			}
-			s += (uintptr(j + 1))
+			s += uintptr(j + 1)
 		}
 		return 0
 	} else if af != 10 {
-		(*(*int32)(unsafe.Pointer(X___errno_location(tls)))) = 97
+		*(*int32)(unsafe.Pointer(X___errno_location(tls))) = 97
 		return -1
 	}
 
-	if (int32(*(*int8)(unsafe.Pointer(s))) == ':') && (int32(*(*int8)(unsafe.Pointer(PreIncUintptr(&s, 1)))) != ':') {
+	if int32(*(*int8)(unsafe.Pointer(s))) == ':' && int32(*(*int8)(unsafe.Pointer(PreIncUintptr(&s, 1)))) != ':' {
 		return 0
 	}
 
 	for i = 0; ; i++ {
-		if (int32(*(*int8)(unsafe.Pointer(s))) == ':') && (brk < 0) {
+		if int32(*(*int8)(unsafe.Pointer(s))) == ':' && brk < 0 {
 			brk = i
-			*(*uint16_t)(unsafe.Pointer(bp /* &ip[0] */ + uintptr((i&7))*2)) = uint16_t(0)
+			*(*uint16_t)(unsafe.Pointer(bp + uintptr(i&7)*2)) = uint16_t(0)
 			if !(int32(*(*int8)(unsafe.Pointer(PreIncUintptr(&s, 1)))) != 0) {
 				break
 			}
@@ -4856,40 +4856,40 @@ func Xinet_pton(tls *TLS, af int32, s uintptr, a0 uintptr) int32 { /* inet_pton.
 			}
 			continue
 		}
-		for v = AssignInt32(&j, 0); (j < 4) && ((AssignInt32(&d, hexval(tls, uint32(*(*int8)(unsafe.Pointer(s + uintptr(j))))))) >= 0); j++ {
-			v = ((16 * v) + d)
+		for v = AssignInt32(&j, 0); j < 4 && AssignInt32(&d, hexval(tls, uint32(*(*int8)(unsafe.Pointer(s + uintptr(j)))))) >= 0; j++ {
+			v = 16*v + d
 		}
 		if j == 0 {
 			return 0
 		}
-		*(*uint16_t)(unsafe.Pointer(bp /* &ip[0] */ + uintptr((i&7))*2)) = uint16_t(v)
-		if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != 0) && ((brk >= 0) || (i == 7)) {
+		*(*uint16_t)(unsafe.Pointer(bp + uintptr(i&7)*2)) = uint16_t(v)
+		if !(int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != 0) && (brk >= 0 || i == 7) {
 			break
 		}
 		if i == 7 {
 			return 0
 		}
 		if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != ':' {
-			if (int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != '.') || ((i < 6) && (brk < 0)) {
+			if int32(*(*int8)(unsafe.Pointer(s + uintptr(j)))) != '.' || i < 6 && brk < 0 {
 				return 0
 			}
 			need_v4 = 1
 			i++
 			break
 		}
-		s += (uintptr(j + 1))
+		s += uintptr(j + 1)
 	}
 	if brk >= 0 {
-		Xmemmove(tls, (((bp /* &ip[0] */ + uintptr(brk)*2) + uintptr(7)*2) - uintptr(i)*2), (bp /* &ip[0] */ + uintptr(brk)*2), (uint64(2 * ((i + 1) - brk))))
-		for j = 0; j < (7 - i); j++ {
-			*(*uint16_t)(unsafe.Pointer(bp /* &ip[0] */ + uintptr((brk+j))*2)) = uint16_t(0)
+		Xmemmove(tls, bp+uintptr(brk)*2+uintptr(7)*2-uintptr(i)*2, bp+uintptr(brk)*2, uint64(2*(i+1-brk)))
+		for j = 0; j < 7-i; j++ {
+			*(*uint16_t)(unsafe.Pointer(bp + uintptr(brk+j)*2)) = uint16_t(0)
 		}
 	}
 	for j = 0; j < 8; j++ {
-		*(*uint8)(unsafe.Pointer(PostIncUintptr(&a, 1))) = (uint8(int32(*(*uint16_t)(unsafe.Pointer(bp /* &ip[0] */ + uintptr(j)*2))) >> 8))
-		*(*uint8)(unsafe.Pointer(PostIncUintptr(&a, 1))) = uint8(*(*uint16_t)(unsafe.Pointer(bp /* &ip[0] */ + uintptr(j)*2)))
+		*(*uint8)(unsafe.Pointer(PostIncUintptr(&a, 1))) = uint8(int32(*(*uint16_t)(unsafe.Pointer(bp + uintptr(j)*2))) >> 8)
+		*(*uint8)(unsafe.Pointer(PostIncUintptr(&a, 1))) = uint8(*(*uint16_t)(unsafe.Pointer(bp + uintptr(j)*2)))
 	}
-	if (need_v4 != 0) && (Xinet_pton(tls, 2, s, (a-uintptr(4))) <= 0) {
+	if need_v4 != 0 && Xinet_pton(tls, 2, s, a-uintptr(4)) <= 0 {
 		return 0
 	}
 	return 1
@@ -4903,11 +4903,11 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) int3
 
 	// var a6 in6_addr at bp+68, 16
 
-	if X__inet_aton(tls, name, bp /* &a4 */) > 0 {
+	if X__inet_aton(tls, name, bp) > 0 {
 		if family == 10 { // wrong family
 			return -2
 		}
-		Xmemcpy(tls, (buf + 8 /* &.addr */), bp /* &a4 */, uint64(unsafe.Sizeof(in_addr{})))
+		Xmemcpy(tls, buf+8, bp, uint64(unsafe.Sizeof(in_addr{})))
 		(*address)(unsafe.Pointer(buf)).family = 2
 		(*address)(unsafe.Pointer(buf)).scopeid = uint32(0)
 		return 1
@@ -4918,33 +4918,33 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) int3
 	// var z uintptr at bp+88, 8
 
 	var scopeid uint64 = uint64(0)
-	if (p != 0) && (((int64(p) - int64(name)) / 1) < int64(64)) {
-		Xmemcpy(tls, bp+4 /* &tmp[0] */, name, (uint64((int64(p) - int64(name)) / 1)))
-		*(*int8)(unsafe.Pointer(bp + 4 /* &tmp[0] */ + uintptr(((int64(p) - int64(name)) / 1)))) = int8(0)
+	if p != 0 && (int64(p)-int64(name))/1 < int64(64) {
+		Xmemcpy(tls, bp+4, name, uint64((int64(p)-int64(name))/1))
+		*(*int8)(unsafe.Pointer(bp + 4 + uintptr((int64(p)-int64(name))/1))) = int8(0)
 		name = bp + 4 /* &tmp[0] */
 	}
 
-	if Xinet_pton(tls, 10, name, bp+68 /* &a6 */) <= 0 {
+	if Xinet_pton(tls, 10, name, bp+68) <= 0 {
 		return 0
 	}
 	if family == 2 { // wrong family
 		return -2
 	}
 
-	Xmemcpy(tls, (buf + 8 /* &.addr */), bp+68 /* &a6 */, uint64(unsafe.Sizeof(in6_addr{})))
+	Xmemcpy(tls, buf+8, bp+68, uint64(unsafe.Sizeof(in6_addr{})))
 	(*address)(unsafe.Pointer(buf)).family = 10
 	if p != 0 {
 		if func() int32 {
 			if 0 != 0 {
 				return Xisdigit(tls, int32(*(*int8)(unsafe.Pointer(PreIncUintptr(&p, 1)))))
 			}
-			return (Bool32(((uint32(*(*int8)(unsafe.Pointer(PreIncUintptr(&p, 1))))) - uint32('0')) < uint32(10)))
+			return Bool32(uint32(*(*int8)(unsafe.Pointer(PreIncUintptr(&p, 1))))-uint32('0') < uint32(10))
 		}() != 0 {
-			scopeid = Xstrtoull(tls, p, bp+88 /* &z */, 10)
+			scopeid = Xstrtoull(tls, p, bp+88, 10)
 		} else {
-			*(*uintptr)(unsafe.Pointer(bp + 88 /* z */)) = (p - uintptr(1))
+			*(*uintptr)(unsafe.Pointer(bp + 88 /* z */)) = p - uintptr(1)
 		}
-		if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88 /* z */)))) != 0 {
+		if *(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp + 88)))) != 0 {
 			Xabort(tls) //TODO-
 			// if (!IN6_IS_ADDR_LINKLOCAL(&a6) &&
 			//     !IN6_IS_ADDR_MC_LINKLOCAL(&a6))
@@ -4963,10 +4963,10 @@ func X__lookup_ipliteral(tls *TLS, buf uintptr, name uintptr, family int32) int3
 func is_valid_hostname(tls *TLS, host uintptr) int32 { /* lookup_name.c:18:12: */
 	var s uintptr
 	//TODO if (strnlen(host, 255)-1 >= 254 || mbstowcs(0, host, 0) == -1) return 0;
-	if (Xstrnlen(tls, host, uint64(255)) - uint64(1)) >= uint64(254) {
+	if Xstrnlen(tls, host, uint64(255))-uint64(1) >= uint64(254) {
 		return 0
 	}
-	for s = host; (((int32(*(*uint8)(unsafe.Pointer(s))) >= 0x80) || (int32(*(*uint8)(unsafe.Pointer(s))) == '.')) || (int32(*(*uint8)(unsafe.Pointer(s))) == '-')) || (Xisalnum(tls, int32(*(*uint8)(unsafe.Pointer(s)))) != 0); s++ {
+	for s = host; int32(*(*uint8)(unsafe.Pointer(s))) >= 0x80 || int32(*(*uint8)(unsafe.Pointer(s))) == '.' || int32(*(*uint8)(unsafe.Pointer(s))) == '-' || Xisalnum(tls, int32(*(*uint8)(unsafe.Pointer(s)))) != 0; s++ {
 	}
 	return BoolInt32(!(*(*uint8)(unsafe.Pointer(s)) != 0))
 }
@@ -4978,7 +4978,7 @@ func name_from_null(tls *TLS, buf uintptr, name uintptr, family int32, flags int
 	if name != 0 {
 		return 0
 	}
-	if (flags & 0x01) != 0 {
+	if flags&0x01 != 0 {
 		//TODO if (family != AF_INET6)
 		//TODO 	buf[cnt++] = (struct address){ .family = AF_INET };
 		if family != 10 {
@@ -5021,7 +5021,7 @@ func name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family
 	//TODO FILE _f, *f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
 	var _f FILE
 	_ = _f
-	var f uintptr = Xfopen(tls, ts+76 /* "/etc/hosts" */, ts+87 /* "rb" */)
+	var f uintptr = Xfopen(tls, ts+76, ts+87)
 	if !(f != 0) {
 		switch *(*int32)(unsafe.Pointer(X___errno_location(tls))) {
 		case 2:
@@ -5035,25 +5035,25 @@ func name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family
 			return -11
 		}
 	}
-	for (Xfgets(tls, bp /* &line[0] */, int32(unsafe.Sizeof([512]int8{})), f) != 0) && (cnt < 48) {
+	for Xfgets(tls, bp, int32(unsafe.Sizeof([512]int8{})), f) != 0 && cnt < 48 {
 		var p uintptr
 		var z uintptr
 
-		if AssignUintptr(&p, Xstrchr(tls, bp /* &line[0] */, '#')) != 0 {
+		if AssignUintptr(&p, Xstrchr(tls, bp, '#')) != 0 {
 			*(*int8)(unsafe.Pointer(PostIncUintptr(&p, 1))) = int8('\n')
 			*(*int8)(unsafe.Pointer(p)) = int8(0)
 		}
-		for p = (bp /* &line[0] */ + uintptr(1)); (AssignUintptr(&p, Xstrstr(tls, p, name)) != 0) && (!(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p + UintptrFromInt32(-1))))) != 0) || !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p + uintptr(l))))) != 0)); p++ {
+		for p = bp + uintptr(1); AssignUintptr(&p, Xstrstr(tls, p, name)) != 0 && (!(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p + UintptrFromInt32(-1))))) != 0) || !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p + uintptr(l))))) != 0)); p++ {
 		}
 		if !(p != 0) {
 			continue
 		}
 
 		// Isolate IP address to parse
-		for p = bp; /* &line[0] */ (*(*int8)(unsafe.Pointer(p)) != 0) && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
+		for p = bp; /* &line[0] */ *(*int8)(unsafe.Pointer(p)) != 0 && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
 		}
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&p, 1))) = int8(0)
-		switch name_from_numeric(tls, (buf + uintptr(cnt)*28), bp /* &line[0] */, family) {
+		switch name_from_numeric(tls, buf+uintptr(cnt)*28, bp, family) {
 		case 1:
 			cnt++
 			break
@@ -5065,13 +5065,13 @@ func name_from_hosts(tls *TLS, buf uintptr, canon uintptr, name uintptr, family
 		}
 
 		// Extract first name as canonical name
-		for ; (*(*int8)(unsafe.Pointer(p)) != 0) && (__isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0); p++ {
+		for ; *(*int8)(unsafe.Pointer(p)) != 0 && __isspace(tls, int32(*(*int8)(unsafe.Pointer(p)))) != 0; p++ {
 		}
-		for z = p; (*(*int8)(unsafe.Pointer(z)) != 0) && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(z)))) != 0); z++ {
+		for z = p; *(*int8)(unsafe.Pointer(z)) != 0 && !(__isspace(tls, int32(*(*int8)(unsafe.Pointer(z)))) != 0); z++ {
 		}
 		*(*int8)(unsafe.Pointer(z)) = int8(0)
 		if is_valid_hostname(tls, p) != 0 {
-			Xmemcpy(tls, canon, p, (uint64(((int64(z) - int64(p)) / 1) + int64(1))))
+			Xmemcpy(tls, canon, p, uint64((int64(z)-int64(p))/1+int64(1)))
 		}
 	}
 	//TODO __fclose_ca(f);
@@ -5144,26 +5144,26 @@ type policy = struct {
 } /* lookup_name.c:237:14 */
 
 var defpolicy = [6]policy{
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 172 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" */)), len: uint8(15), mask: uint8(0xff), prec: uint8(50)},
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 189 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00" */)), len: uint8(11), mask: uint8(0xff), prec: uint8(35), label: uint8(4)},
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 205 /* " \x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" */)), len: uint8(1), mask: uint8(0xff), prec: uint8(30), label: uint8(2)},
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 221 /* " \x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" */)), len: uint8(3), mask: uint8(0xff), prec: uint8(5), label: uint8(5)},
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 237 /* "\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" */)), mask: uint8(0xfe), prec: uint8(3), label: uint8(13)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 172)), len: uint8(15), mask: uint8(0xff), prec: uint8(50)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 189)), len: uint8(11), mask: uint8(0xff), prec: uint8(35), label: uint8(4)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 205)), len: uint8(1), mask: uint8(0xff), prec: uint8(30), label: uint8(2)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 221)), len: uint8(3), mask: uint8(0xff), prec: uint8(5), label: uint8(5)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 237)), mask: uint8(0xfe), prec: uint8(3), label: uint8(13)},
 	// Last rule must match all addresses to stop loop.
-	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 253 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" */)), prec: uint8(40), label: uint8(1)},
+	{addr: *(*[16]uint8)(unsafe.Pointer(ts + 253)), prec: uint8(40), label: uint8(1)},
 } /* lookup_name.c:241:3 */
 
 func policyof(tls *TLS, a uintptr) uintptr { /* lookup_name.c:259:28: */
 	var i int32
 	for i = 0; ; i++ {
-		if Xmemcmp(tls, a /* &.__in6_union */ /* &.__s6_addr */, uintptr(unsafe.Pointer(&defpolicy))+uintptr(i)*20 /* &.addr */, uint64(defpolicy[i].len)) != 0 {
+		if Xmemcmp(tls, a, uintptr(unsafe.Pointer(&defpolicy))+uintptr(i)*20, uint64(defpolicy[i].len)) != 0 {
 			continue
 		}
-		if (int32(*(*uint8_t)(unsafe.Pointer((a /* &.__in6_union */ /* &.__s6_addr */) + uintptr(defpolicy[i].len)))) & int32(defpolicy[i].mask)) !=
-			int32(*(*uint8)(unsafe.Pointer((uintptr(unsafe.Pointer(&defpolicy)) + uintptr(i)*20 /* &.addr */) + uintptr(defpolicy[i].len)))) {
+		if int32(*(*uint8_t)(unsafe.Pointer(a + uintptr(defpolicy[i].len))))&int32(defpolicy[i].mask) !=
+			int32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(&defpolicy)) + uintptr(i)*20 + uintptr(defpolicy[i].len)))) {
 			continue
 		}
-		return (uintptr(unsafe.Pointer(&defpolicy)) + uintptr(i)*20)
+		return uintptr(unsafe.Pointer(&defpolicy)) + uintptr(i)*20
 	}
 	return uintptr(0)
 }
@@ -5173,16 +5173,16 @@ func labelof(tls *TLS, a uintptr) int32 { /* lookup_name.c:272:12: */
 }
 
 func scopeof(tls *TLS, a uintptr) int32 { /* lookup_name.c:277:12: */
-	if int32(*(*uint8_t)(unsafe.Pointer((a)))) == 0xff {
-		return (int32(*(*uint8_t)(unsafe.Pointer((a /* &.__in6_union */ /* &.__s6_addr */) + 1))) & 15)
+	if int32(*(*uint8_t)(unsafe.Pointer(a))) == 0xff {
+		return int32(*(*uint8_t)(unsafe.Pointer(a + 1))) & 15
 	}
-	if ((int32(*(*uint8_t)(unsafe.Pointer((a))))) == 0xfe) && ((int32(*(*uint8_t)(unsafe.Pointer((a) + 1))) & 0xc0) == 0x80) {
+	if int32(*(*uint8_t)(unsafe.Pointer(a))) == 0xfe && int32(*(*uint8_t)(unsafe.Pointer(a + 1)))&0xc0 == 0x80 {
 		return 2
 	}
-	if ((((((*(*uint32_t)(unsafe.Pointer((a))) == uint32_t(0)) && (*(*uint32_t)(unsafe.Pointer((a) + 1*4)) == uint32_t(0))) && (*(*uint32_t)(unsafe.Pointer((a) + 2*4)) == uint32_t(0))) && (int32(*(*uint8_t)(unsafe.Pointer((a) + 12))) == 0)) && (int32(*(*uint8_t)(unsafe.Pointer((a) + 13))) == 0)) && (int32(*(*uint8_t)(unsafe.Pointer((a) + 14))) == 0)) && (int32(*(*uint8_t)(unsafe.Pointer((a) + 15))) == 1) {
+	if *(*uint32_t)(unsafe.Pointer(a)) == uint32_t(0) && *(*uint32_t)(unsafe.Pointer(a + 1*4)) == uint32_t(0) && *(*uint32_t)(unsafe.Pointer(a + 2*4)) == uint32_t(0) && int32(*(*uint8_t)(unsafe.Pointer(a + 12))) == 0 && int32(*(*uint8_t)(unsafe.Pointer(a + 13))) == 0 && int32(*(*uint8_t)(unsafe.Pointer(a + 14))) == 0 && int32(*(*uint8_t)(unsafe.Pointer(a + 15))) == 1 {
 		return 2
 	}
-	if ((int32(*(*uint8_t)(unsafe.Pointer((a))))) == 0xfe) && ((int32(*(*uint8_t)(unsafe.Pointer((a) + 1))) & 0xc0) == 0xc0) {
+	if int32(*(*uint8_t)(unsafe.Pointer(a))) == 0xfe && int32(*(*uint8_t)(unsafe.Pointer(a + 1)))&0xc0 == 0xc0 {
 		return 5
 	}
 	return 14
@@ -5194,7 +5194,7 @@ func prefixmatch(tls *TLS, s uintptr, d uintptr) int32 { /* lookup_name.c:286:12
 	// address. However the definition of the source prefix length is
 	// not clear and thus this limiting is not yet implemented.
 	var i uint32
-	for i = uint32(0); (i < uint32(128)) && !(((int32(*(*uint8_t)(unsafe.Pointer((s /* &.__in6_union */ /* &.__s6_addr */) + uintptr((i / uint32(8)))))) ^ int32(*(*uint8_t)(unsafe.Pointer((d /* &.__in6_union */ /* &.__s6_addr */) + uintptr((i / uint32(8))))))) & (int32(128) >> (i % uint32(8)))) != 0); i++ {
+	for i = uint32(0); i < uint32(128) && !((int32(*(*uint8_t)(unsafe.Pointer(s /* &.__in6_union */ /* &.__s6_addr */ + uintptr(i/uint32(8)))))^int32(*(*uint8_t)(unsafe.Pointer(d /* &.__in6_union */ /* &.__s6_addr */ + uintptr(i/uint32(8))))))&(int32(128)>>(i%uint32(8))) != 0); i++ {
 	}
 	return int32(i)
 }
@@ -5202,7 +5202,7 @@ func prefixmatch(tls *TLS, s uintptr, d uintptr) int32 { /* lookup_name.c:286:12
 func addrcmp(tls *TLS, _a uintptr, _b uintptr) int32 { /* lookup_name.c:305:12: */
 	var a uintptr = _a
 	var b uintptr = _b
-	return ((*address)(unsafe.Pointer(b)).sortkey - (*address)(unsafe.Pointer(a)).sortkey)
+	return (*address)(unsafe.Pointer(b)).sortkey - (*address)(unsafe.Pointer(a)).sortkey
 }
 
 func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family int32, flags int32) int32 { /* lookup_name.c:311:5: */
@@ -5218,20 +5218,20 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i
 	if name != 0 {
 		// reject empty name and check len so it fits into temp bufs
 		var l size_t = Xstrnlen(tls, name, uint64(255))
-		if (l - uint64(1)) >= uint64(254) {
+		if l-uint64(1) >= uint64(254) {
 			return -2
 		}
-		Xmemcpy(tls, canon, name, (l + uint64(1)))
+		Xmemcpy(tls, canon, name, l+uint64(1))
 	}
 
 	// Procedurally, a request for v6 addresses with the v4-mapped
 	// flag set is like a request for unspecified family, followed
 	// by filtering of the results.
-	if (flags & 0x08) != 0 {
+	if flags&0x08 != 0 {
 		if family == 10 {
 			family = 0
 		} else {
-			flags = flags - (0x08)
+			flags = flags - 0x08
 		}
 	}
 
@@ -5240,7 +5240,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i
 	if !(cnt != 0) {
 		cnt = name_from_numeric(tls, buf, name, family)
 	}
-	if !(cnt != 0) && !((flags & 0x04) != 0) {
+	if !(cnt != 0) && !(flags&0x04 != 0) {
 		cnt = name_from_hosts(tls, buf, canon, name, family)
 		if !(cnt != 0) {
 			cnt = name_from_dns_search(tls, buf, canon, name, family)
@@ -5254,7 +5254,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i
 	}
 
 	// Filter/transform results for v4-mapped lookup, if requested.
-	if (flags & 0x08) != 0 {
+	if flags&0x08 != 0 {
 		Xabort(tls) //TODO-
 		// 	if (!(flags & AI_ALL)) {
 		// 		/* If any v6 results exist, remove v4 results. */
@@ -5278,7 +5278,7 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i
 
 	// No further processing is needed if there are fewer than 2
 	// results or if there are only IPv4 results.
-	if (cnt < 2) || (family == 2) {
+	if cnt < 2 || family == 2 {
 		return cnt
 	}
 	for i = 0; i < cnt; i++ {
@@ -5311,55 +5311,55 @@ func X__lookup_name(tls *TLS, buf uintptr, canon uintptr, name uintptr, family i
 
 		var dalen socklen_t
 		if family == 10 {
-			Xmemcpy(tls, bp /* &da6 */ +8 /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */, buf+uintptr(i)*28+8 /* &.addr */, uint64(16))
+			Xmemcpy(tls, bp+8, buf+uintptr(i)*28+8, uint64(16))
 			da = bp /* &da6 */
 			dalen = socklen_t(unsafe.Sizeof(sockaddr_in6{}))
 			sa1 = bp + 28 /* &sa6 */
 			*(*socklen_t)(unsafe.Pointer(bp + 88 /* salen */)) = socklen_t(unsafe.Sizeof(sockaddr_in6{}))
 		} else {
-			Xmemcpy(tls, bp+28 /* &sa6 */ +8, /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */
-				ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12))
-			Xmemcpy(tls, ((bp /* &da6 */ + 8 /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */) + uintptr(12)), buf+uintptr(i)*28+8 /* &.addr */, uint64(4))
-			Xmemcpy(tls, bp /* &da6 */ +8, /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */
-				ts+90 /* "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff" */, uint64(12))
-			Xmemcpy(tls, ((bp /* &da6 */ + 8 /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */) + uintptr(12)), buf+uintptr(i)*28+8 /* &.addr */, uint64(4))
-			Xmemcpy(tls, (bp + 56 /* &da4 */ + 4 /* &.sin_addr */), buf+uintptr(i)*28+8 /* &.addr */, uint64(4))
+			Xmemcpy(tls, bp+28+8,
+				ts+90, uint64(12))
+			Xmemcpy(tls, bp+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4))
+			Xmemcpy(tls, bp+8,
+				ts+90, uint64(12))
+			Xmemcpy(tls, bp+8+uintptr(12), buf+uintptr(i)*28+8, uint64(4))
+			Xmemcpy(tls, bp+56+4, buf+uintptr(i)*28+8, uint64(4))
 			da = bp + 56 /* &da4 */
 			dalen = socklen_t(unsafe.Sizeof(sockaddr_in{}))
 			sa1 = bp + 72 /* &sa4 */
 			*(*socklen_t)(unsafe.Pointer(bp + 88 /* salen */)) = socklen_t(unsafe.Sizeof(sockaddr_in{}))
 		}
-		var dpolicy uintptr = policyof(tls, (bp /* &da6 */ + 8 /* &.sin6_addr */))
-		var dscope int32 = scopeof(tls, (bp /* &da6 */ + 8 /* &.sin6_addr */))
+		var dpolicy uintptr = policyof(tls, bp+8)
+		var dscope int32 = scopeof(tls, bp+8)
 		var dlabel int32 = int32((*policy)(unsafe.Pointer(dpolicy)).label)
 		var dprec int32 = int32((*policy)(unsafe.Pointer(dpolicy)).prec)
 		var prefixlen int32 = 0
-		var fd int32 = Xsocket(tls, family, (2 | 02000000), 17)
+		var fd int32 = Xsocket(tls, family, 2|02000000, 17)
 		if fd >= 0 {
 			if !(Xconnect(tls, fd, da, dalen) != 0) {
-				key = key | (0x40000000)
-				if !(Xgetsockname(tls, fd, sa1, bp+88 /* &salen */) != 0) {
+				key = key | 0x40000000
+				if !(Xgetsockname(tls, fd, sa1, bp+88) != 0) {
 					if family == 2 {
 						Xmemcpy(tls,
-							((bp + 28 /* &sa6 */ + 8 /* &.sin6_addr */ /* &.__in6_union */ /* &.__s6_addr */) + uintptr(12)),
-							(bp + 72 /* &sa4 */ + 4 /* &.sin_addr */), uint64(4))
+							bp+28+8+uintptr(12),
+							bp+72+4, uint64(4))
 					}
-					if dscope == scopeof(tls, (bp+28 /* &sa6 */ +8 /* &.sin6_addr */)) {
-						key = key | (0x20000000)
+					if dscope == scopeof(tls, bp+28+8) {
+						key = key | 0x20000000
 					}
-					if dlabel == labelof(tls, (bp+28 /* &sa6 */ +8 /* &.sin6_addr */)) {
-						key = key | (0x10000000)
+					if dlabel == labelof(tls, bp+28+8) {
+						key = key | 0x10000000
 					}
-					prefixlen = prefixmatch(tls, (bp + 28 /* &sa6 */ + 8 /* &.sin6_addr */),
-						(bp /* &da6 */ + 8 /* &.sin6_addr */))
+					prefixlen = prefixmatch(tls, bp+28+8,
+						bp+8)
 				}
 			}
 			Xclose(tls, fd)
 		}
-		key = key | (dprec << 20)
-		key = key | ((15 - dscope) << 16)
-		key = key | (prefixlen << 8)
-		key = key | ((48 - i) << 0)
+		key = key | dprec<<20
+		key = key | (15-dscope)<<16
+		key = key | prefixlen<<8
+		key = key | (48-i)<<0
 		(*address)(unsafe.Pointer(buf + uintptr(i)*28)).sortkey = key
 	}
 	Xqsort(tls, buf, uint64(cnt), uint64(unsafe.Sizeof(address{})), *(*uintptr)(unsafe.Pointer(&struct {
@@ -5422,9 +5422,9 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i
 		if !(int32(*(*int8)(unsafe.Pointer(name))) != 0) {
 			return -8
 		}
-		port = Xstrtoul(tls, name, bp /* &z */, 10)
+		port = Xstrtoul(tls, name, bp, 10)
 	}
-	if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp /* z */))))) != 0) {
+	if !(int32(*(*int8)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(bp))))) != 0) {
 		if port > uint64(65535) {
 			return -8
 		}
@@ -5441,7 +5441,7 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i
 		return cnt
 	}
 
-	if (flags & 0x400) != 0 {
+	if flags&0x400 != 0 {
 		return -2
 	}
 
@@ -5497,55 +5497,55 @@ func X__lookup_serv(tls *TLS, buf uintptr, name uintptr, proto int32, socktype i
 }
 
 func temper(tls *TLS, x uint32) uint32 { /* rand_r.c:3:17: */
-	x = x ^ (x >> 11)
-	x = x ^ ((x << 7) & 0x9D2C5680)
-	x = x ^ ((x << 15) & 0xEFC60000)
-	x = x ^ (x >> 18)
+	x = x ^ x>>11
+	x = x ^ x<<7&0x9D2C5680
+	x = x ^ x<<15&0xEFC60000
+	x = x ^ x>>18
 	return x
 }
 
 func Xrand_r(tls *TLS, seed uintptr) int32 { /* rand_r.c:12:5: */
-	return (int32(temper(tls, AssignPtrUint32(seed, ((*(*uint32)(unsafe.Pointer(seed))*uint32(1103515245))+uint32(12345)))) / uint32(2)))
+	return int32(temper(tls, AssignPtrUint32(seed, *(*uint32)(unsafe.Pointer(seed))*uint32(1103515245)+uint32(12345))) / uint32(2))
 }
 
 func X__lockfile(tls *TLS, f uintptr) int32 { /* __lockfile.c:4:5: */
 	var owner int32 = (*FILE)(unsafe.Pointer(f)).lock
 	var tid int32 = (*__pthread)(unsafe.Pointer(__pthread_self(tls))).tid
-	if (owner & CplInt32(0x40000000)) == tid {
+	if owner&CplInt32(0x40000000) == tid {
 		return 0
 	}
-	owner = a_cas(tls, (f + 140 /* &.lock */), 0, tid)
+	owner = a_cas(tls, f+140, 0, tid)
 	if !(owner != 0) {
 		return 1
 	}
-	for AssignInt32(&owner, a_cas(tls, (f+140 /* &.lock */), 0, (tid|0x40000000))) != 0 {
-		if ((owner & 0x40000000) != 0) || (a_cas(tls, (f+140 /* &.lock */), owner, (owner|0x40000000)) == owner) {
-			__futexwait(tls, (f + 140 /* &.lock */), (owner | 0x40000000), 1)
+	for AssignInt32(&owner, a_cas(tls, f+140, 0, tid|0x40000000)) != 0 {
+		if owner&0x40000000 != 0 || a_cas(tls, f+140, owner, owner|0x40000000) == owner {
+			__futexwait(tls, f+140, owner|0x40000000, 1)
 		}
 	}
 	return 1
 }
 
 func X__unlockfile(tls *TLS, f uintptr) { /* __lockfile.c:19:6: */
-	if (a_swap(tls, (f+140 /* &.lock */), 0) & 0x40000000) != 0 {
-		__wake(tls, (f + 140 /* &.lock */), 1, 1)
+	if a_swap(tls, f+140, 0)&0x40000000 != 0 {
+		__wake(tls, f+140, 1, 1)
 	}
 }
 
 func X__toread(tls *TLS, f uintptr) int32 { /* __toread.c:3:5: */
-	*(*int32)(unsafe.Pointer(f + 136 /* &.mode */)) |= ((*FILE)(unsafe.Pointer(f)).mode - 1)
+	*(*int32)(unsafe.Pointer(f + 136)) |= (*FILE)(unsafe.Pointer(f)).mode - 1
 	if (*FILE)(unsafe.Pointer(f)).wpos != (*FILE)(unsafe.Pointer(f)).wbase {
 		(*struct {
 			f func(*TLS, uintptr, uintptr, size_t) size_t
 		})(unsafe.Pointer(&struct{ uintptr }{(*FILE)(unsafe.Pointer(f)).write})).f(tls, f, uintptr(0), uint64(0))
 	}
-	(*FILE)(unsafe.Pointer(f)).wpos = AssignPtrUintptr(f+56 /* &.wbase */, AssignPtrUintptr(f+32 /* &.wend */, uintptr(0)))
-	if ((*FILE)(unsafe.Pointer(f)).flags & uint32(4)) != 0 {
-		*(*uint32)(unsafe.Pointer(f /* &.flags */)) |= (uint32(32))
+	(*FILE)(unsafe.Pointer(f)).wpos = AssignPtrUintptr(f+56, AssignPtrUintptr(f+32, uintptr(0)))
+	if (*FILE)(unsafe.Pointer(f)).flags&uint32(4) != 0 {
+		*(*uint32)(unsafe.Pointer(f)) |= uint32(32)
 		return -1
 	}
-	(*FILE)(unsafe.Pointer(f)).rpos = AssignPtrUintptr(f+16 /* &.rend */, ((*FILE)(unsafe.Pointer(f)).buf + uintptr((*FILE)(unsafe.Pointer(f)).buf_size)))
-	if ((*FILE)(unsafe.Pointer(f)).flags & uint32(16)) != 0 {
+	(*FILE)(unsafe.Pointer(f)).rpos = AssignPtrUintptr(f+16, (*FILE)(unsafe.Pointer(f)).buf+uintptr((*FILE)(unsafe.Pointer(f)).buf_size))
+	if (*FILE)(unsafe.Pointer(f)).flags&uint32(16) != 0 {
 		return -1
 	}
 	return 0
@@ -5565,10 +5565,10 @@ func X__uflow(tls *TLS, f uintptr) int32 { /* __uflow.c:6:5: */
 
 	// var c uint8 at bp, 1
 
-	if !(X__toread(tls, f) != 0) && ((*struct {
+	if !(X__toread(tls, f) != 0) && (*struct {
 		f func(*TLS, uintptr, uintptr, size_t) size_t
-	})(unsafe.Pointer(&struct{ uintptr }{(*FILE)(unsafe.Pointer(f)).read})).f(tls, f, bp /* &c */, uint64(1)) == uint64(1)) {
-		return int32(*(*uint8)(unsafe.Pointer(bp /* c */)))
+	})(unsafe.Pointer(&struct{ uintptr }{(*FILE)(unsafe.Pointer(f)).read})).f(tls, f, bp, uint64(1)) == uint64(1) {
+		return int32(*(*uint8)(unsafe.Pointer(bp)))
 	}
 	return -1
 }
@@ -5657,19 +5657,19 @@ func Xvfscanf(tls *TLS, f uintptr, fmt uintptr, ap va_list) int32 { /* vfscanf.c
 	matches = 0
 	pos = int64(0)
 	__need_unlock = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).lock >= 0 {
+		if (*FILE)(unsafe.Pointer(f)).lock >= 0 {
 			return X__lockfile(tls, f)
 		}
 		return 0
 	}()
 
-	if !(!(int32((*FILE)(unsafe.Pointer(f)).rpos) != 0)) {
+	if !!(int32((*FILE)(unsafe.Pointer(f)).rpos) != 0) {
 		goto __1
 	}
 	X__toread(tls, f)
 __1:
 	;
-	if !(!(int32((*FILE)(unsafe.Pointer(f)).rpos) != 0)) {
+	if !!(int32((*FILE)(unsafe.Pointer(f)).rpos) != 0) {
 		goto __2
 	}
 	goto input_fail
@@ -5698,7 +5698,7 @@ __8:
 	X__shlim(tls, f, int64(0))
 __9:
 	if !(__isspace(tls, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -5708,15 +5708,15 @@ __9:
 	goto __9
 __10:
 	;
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
-	pos = pos + ((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1))
+	pos = pos + ((*FILE)(unsafe.Pointer(f)).shcnt + (int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1)
 	goto __4
 __6:
 	;
-	if !((int32(*(*uint8)(unsafe.Pointer(p))) != '%') || (int32(*(*uint8)(unsafe.Pointer(p + 1))) == '%')) {
+	if !(int32(*(*uint8)(unsafe.Pointer(p))) != '%' || int32(*(*uint8)(unsafe.Pointer(p + 1))) == '%') {
 		goto __11
 	}
 	X__shlim(tls, f, int64(0))
@@ -5726,7 +5726,7 @@ __6:
 	p++
 __14:
 	if !(__isspace(tls, AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -5739,7 +5739,7 @@ __15:
 	goto __13
 __12:
 	c = func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -5749,7 +5749,7 @@ __13:
 	if !(c != int32(*(*uint8)(unsafe.Pointer(p)))) {
 		goto __16
 	}
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
@@ -5762,7 +5762,7 @@ __17:
 	goto match_fail
 __16:
 	;
-	pos = pos + ((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1))
+	pos = pos + ((*FILE)(unsafe.Pointer(f)).shcnt + (int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1)
 	goto __4
 __11:
 	;
@@ -5775,15 +5775,15 @@ __11:
 	p++
 	goto __19
 __18:
-	if !((func() int32 {
+	if !(func() int32 {
 		if 0 != 0 {
 			return Xisdigit(tls, int32(*(*uint8)(unsafe.Pointer(p))))
 		}
-		return (Bool32(((uint32(*(*uint8)(unsafe.Pointer(p)))) - uint32('0')) < uint32(10)))
-	}() != 0) && (int32(*(*uint8)(unsafe.Pointer(p + 1))) == '$')) {
+		return Bool32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10))
+	}() != 0 && int32(*(*uint8)(unsafe.Pointer(p + 1))) == '$') {
 		goto __20
 	}
-	dest = arg_n(tls, ap, (uint32(int32(*(*uint8)(unsafe.Pointer(p))) - '0')))
+	dest = arg_n(tls, ap, uint32(int32(*(*uint8)(unsafe.Pointer(p)))-'0'))
 	p += uintptr(2)
 	goto __21
 __20:
@@ -5799,11 +5799,11 @@ __22:
 		if 0 != 0 {
 			return Xisdigit(tls, int32(*(*uint8)(unsafe.Pointer(p))))
 		}
-		return (Bool32(((uint32(*(*uint8)(unsafe.Pointer(p)))) - uint32('0')) < uint32(10)))
+		return Bool32(uint32(*(*uint8)(unsafe.Pointer(p)))-uint32('0') < uint32(10))
 	}() != 0) {
 		goto __24
 	}
-	width = (((10 * width) + int32(*(*uint8)(unsafe.Pointer(p)))) - '0')
+	width = 10*width + int32(*(*uint8)(unsafe.Pointer(p))) - '0'
 	goto __23
 __23:
 	p++
@@ -5817,7 +5817,7 @@ __24:
 	}
 	wcs = uintptr(0)
 	s = uintptr(0)
-	alloc = BoolInt32(!(!(dest != 0)))
+	alloc = BoolInt32(!!(dest != 0))
 	p++
 	goto __26
 __25:
@@ -5950,10 +5950,10 @@ __27:
 	t = int32(*(*uint8)(unsafe.Pointer(p)))
 
 	// C or S
-	if !((t & 0x2f) == 3) {
+	if !(t&0x2f == 3) {
 		goto __60
 	}
-	t = t | (32)
+	t = t | 32
 	size = 1
 __60:
 	;
@@ -5986,7 +5986,7 @@ __65:
 	X__shlim(tls, f, int64(0))
 __67:
 	if !(__isspace(tls, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
@@ -5996,27 +5996,27 @@ __67:
 	goto __67
 __68:
 	;
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
-	pos = pos + ((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1))
+	pos = pos + ((*FILE)(unsafe.Pointer(f)).shcnt + (int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1)
 __61:
 	;
 
 	X__shlim(tls, f, int64(width))
-	if !((func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	if !(func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
-	}()) < 0) {
+	}() < 0) {
 		goto __69
 	}
 	goto input_fail
 __69:
 	;
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
@@ -6063,20 +6063,20 @@ __69:
 __71:
 __72:
 __73:
-	if !((t == 'c') || (t == 's')) {
+	if !(t == 'c' || t == 's') {
 		goto __89
 	}
-	Xmemset(tls, bp /* &scanset[0] */, -1, uint64(unsafe.Sizeof([257]uint8{})))
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */)) = uint8(0)
+	Xmemset(tls, bp, -1, uint64(unsafe.Sizeof([257]uint8{})))
+	*(*uint8)(unsafe.Pointer(bp)) = uint8(0)
 	if !(t == 's') {
 		goto __91
 	}
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 10)) = uint8(0)
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 11)) = uint8(0)
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 12)) = uint8(0)
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 13)) = uint8(0)
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 14)) = uint8(0)
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 33)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 10)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 11)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 12)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 13)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 14)) = uint8(0)
+	*(*uint8)(unsafe.Pointer(bp + 33)) = uint8(0)
 __91:
 	;
 	goto __90
@@ -6091,20 +6091,20 @@ __92:
 	invert = 0
 __93:
 	;
-	Xmemset(tls, bp /* &scanset[0] */, invert, uint64(unsafe.Sizeof([257]uint8{})))
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */)) = uint8(0)
+	Xmemset(tls, bp, invert, uint64(unsafe.Sizeof([257]uint8{})))
+	*(*uint8)(unsafe.Pointer(bp)) = uint8(0)
 	if !(int32(*(*uint8)(unsafe.Pointer(p))) == '-') {
 		goto __94
 	}
 	p++
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 46)) = (uint8(1 - invert))
+	*(*uint8)(unsafe.Pointer(bp + 46)) = uint8(1 - invert)
 	goto __95
 __94:
 	if !(int32(*(*uint8)(unsafe.Pointer(p))) == ']') {
 		goto __96
 	}
 	p++
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + 94)) = (uint8(1 - invert))
+	*(*uint8)(unsafe.Pointer(bp + 94)) = uint8(1 - invert)
 __96:
 	;
 __95:
@@ -6113,13 +6113,13 @@ __97:
 	if !(int32(*(*uint8)(unsafe.Pointer(p))) != ']') {
 		goto __99
 	}
-	if !(!(int32(*(*uint8)(unsafe.Pointer(p))) != 0)) {
+	if !!(int32(*(*uint8)(unsafe.Pointer(p))) != 0) {
 		goto __100
 	}
 	goto fmt_fail
 __100:
 	;
-	if !(((int32(*(*uint8)(unsafe.Pointer(p))) == '-') && (*(*uint8)(unsafe.Pointer(p + 1)) != 0)) && (int32(*(*uint8)(unsafe.Pointer(p + 1))) != ']')) {
+	if !(int32(*(*uint8)(unsafe.Pointer(p))) == '-' && *(*uint8)(unsafe.Pointer(p + 1)) != 0 && int32(*(*uint8)(unsafe.Pointer(p + 1))) != ']') {
 		goto __101
 	}
 	c = int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&p, 1) + UintptrFromInt32(-1))))
@@ -6127,7 +6127,7 @@ __102:
 	if !(c < int32(*(*uint8)(unsafe.Pointer(p)))) {
 		goto __104
 	}
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr((1 + c)))) = (uint8(1 - invert))
+	*(*uint8)(unsafe.Pointer(bp + uintptr(1+c))) = uint8(1 - invert)
 	goto __103
 __103:
 	c++
@@ -6137,7 +6137,7 @@ __104:
 	;
 __101:
 	;
-	*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr((1 + int32(*(*uint8)(unsafe.Pointer(p))))))) = (uint8(1 - invert))
+	*(*uint8)(unsafe.Pointer(bp + uintptr(1+int32(*(*uint8)(unsafe.Pointer(p)))))) = uint8(1 - invert)
 	goto __98
 __98:
 	p++
@@ -6151,7 +6151,7 @@ __90:
 	s = uintptr(0)
 	i = uint64(0)
 	if t == 'c' {
-		k = (uint64(uint32(width) + 1))
+		k = uint64(uint32(width) + 1)
 	} else {
 		k = uint64(31)
 	}
@@ -6161,8 +6161,8 @@ __90:
 	if !(alloc != 0) {
 		goto __107
 	}
-	wcs = Xmalloc(tls, (k * size_t(unsafe.Sizeof(wchar_t(0)))))
-	if !(!(wcs != 0)) {
+	wcs = Xmalloc(tls, k*size_t(unsafe.Sizeof(wchar_t(0))))
+	if !!(wcs != 0) {
 		goto __109
 	}
 	goto alloc_fail
@@ -6175,15 +6175,15 @@ __108:
 	;
 	*(*mbstate_t)(unsafe.Pointer(bp + 268 /* st */)) = mbstate_t{}
 __110:
-	if !(*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr(((AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	if !(*(*uint8)(unsafe.Pointer(bp + uintptr(AssignInt32(&c, func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
-	}())) + 1)))) != 0) {
+	}())+1))) != 0) {
 		goto __111
 	}
-	switch Xmbrtowc(tls, bp+260 /* &wc */, func() uintptr { *(*int8)(unsafe.Pointer(bp + 264)) = int8(c); return bp + 264 }(), uint64(1), bp+268 /* &st */) {
+	switch Xmbrtowc(tls, bp+260, func() uintptr { *(*int8)(unsafe.Pointer(bp + 264)) = int8(c); return bp + 264 }(), uint64(1), bp+268 /* &st */) {
 	case Uint64FromInt32(-1):
 		goto __113
 	case Uint64FromInt32(-2):
@@ -6202,12 +6202,12 @@ __112:
 	*(*wchar_t)(unsafe.Pointer(wcs + uintptr(PostIncUint64(&i, 1))*4)) = *(*wchar_t)(unsafe.Pointer(bp + 260 /* wc */))
 __115:
 	;
-	if !((alloc != 0) && (i == k)) {
+	if !(alloc != 0 && i == k) {
 		goto __116
 	}
 	k = k + (k + uint64(1))
-	tmp = Xrealloc(tls, wcs, (k * size_t(unsafe.Sizeof(wchar_t(0)))))
-	if !(!(tmp != 0)) {
+	tmp = Xrealloc(tls, wcs, k*size_t(unsafe.Sizeof(wchar_t(0))))
+	if !!(tmp != 0) {
 		goto __117
 	}
 	goto alloc_fail
@@ -6219,7 +6219,7 @@ __116:
 	goto __110
 __111:
 	;
-	if !(!(Xmbsinit(tls, bp+268 /* &st */) != 0)) {
+	if !!(Xmbsinit(tls, bp+268) != 0) {
 		goto __118
 	}
 	goto input_fail
@@ -6231,19 +6231,19 @@ __105:
 		goto __119
 	}
 	s = Xmalloc(tls, k)
-	if !(!(s != 0)) {
+	if !!(s != 0) {
 		goto __121
 	}
 	goto alloc_fail
 __121:
 	;
 __122:
-	if !(*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr(((AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	if !(*(*uint8)(unsafe.Pointer(bp + uintptr(AssignInt32(&c, func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
-	}())) + 1)))) != 0) {
+	}())+1))) != 0) {
 		goto __123
 	}
 	*(*int8)(unsafe.Pointer(s + uintptr(PostIncUint64(&i, 1)))) = int8(c)
@@ -6252,7 +6252,7 @@ __122:
 	}
 	k = k + (k + uint64(1))
 	tmp1 = Xrealloc(tls, s, k)
-	if !(!(tmp1 != 0)) {
+	if !!(tmp1 != 0) {
 		goto __125
 	}
 	goto alloc_fail
@@ -6270,12 +6270,12 @@ __119:
 		goto __126
 	}
 __128:
-	if !(*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr(((AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	if !(*(*uint8)(unsafe.Pointer(bp + uintptr(AssignInt32(&c, func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
-	}())) + 1)))) != 0) {
+	}())+1))) != 0) {
 		goto __129
 	}
 	*(*int8)(unsafe.Pointer(s + uintptr(PostIncUint64(&i, 1)))) = int8(c)
@@ -6285,12 +6285,12 @@ __129:
 	goto __127
 __126:
 __130:
-	if !(*(*uint8)(unsafe.Pointer(bp /* &scanset[0] */ + uintptr(((AssignInt32(&c, func() int32 {
-		if (*FILE)(unsafe.Pointer((f))).rpos != (*FILE)(unsafe.Pointer((f))).shend {
+	if !(*(*uint8)(unsafe.Pointer(bp + uintptr(AssignInt32(&c, func() int32 {
+		if (*FILE)(unsafe.Pointer(f)).rpos != (*FILE)(unsafe.Pointer(f)).shend {
 			return int32(*(*uint8)(unsafe.Pointer(PostIncUintptr(&(*FILE)(unsafe.Pointer(f)).rpos, 1))))
 		}
 		return X__shgetc(tls, f)
-	}())) + 1)))) != 0) {
+	}())+1))) != 0) {
 		goto __131
 	}
 	goto __130
@@ -6302,17 +6302,17 @@ __120:
 	;
 __106:
 	;
-	if (*FILE)(unsafe.Pointer((f))).shlim >= int64(0) {
+	if (*FILE)(unsafe.Pointer(f)).shlim >= int64(0) {
 		(*FILE)(unsafe.Pointer(f)).rpos--
 	} else {
 	}
-	if !(!(((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1)) != 0)) {
+	if !!((*FILE)(unsafe.Pointer(f)).shcnt+(int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1 != 0) {
 		goto __132
 	}
 	goto match_fail
 __132:
 	;
-	if !((t == 'c') && (((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1)) != off_t(width))) {
+	if !(t == 'c' && (*FILE)(unsafe.Pointer(f)).shcnt+(int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1 != off_t(width)) {
 		goto __133
 	}
 	goto match_fail
@@ -6365,14 +6365,14 @@ __79:
 __80:
 	base = 0
 int_common:
-	x = X__intscan(tls, f, uint32(base), 0, ((2 * uint64(0x7fffffffffffffff)) + uint64(1)))
-	if !(!(((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1)) != 0)) {
+	x = X__intscan(tls, f, uint32(base), 0, 2*uint64(0x7fffffffffffffff)+uint64(1))
+	if !!((*FILE)(unsafe.Pointer(f)).shcnt+(int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1 != 0) {
 		goto __140
 	}
 	goto match_fail
 __140:
 	;
-	if !((t == 'p') && (dest != 0)) {
+	if !(t == 'p' && dest != 0) {
 		goto __141
 	}
 	*(*uintptr)(unsafe.Pointer(dest)) = uintptr(uintptr_t(x))
@@ -6391,7 +6391,7 @@ __86:
 __87:
 __88:
 	y = X__floatscan(tls, f, size, 0)
-	if !(!(((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1)) != 0)) {
+	if !!((*FILE)(unsafe.Pointer(f)).shcnt+(int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1 != 0) {
 		goto __143
 	}
 	goto match_fail
@@ -6426,7 +6426,7 @@ __144:
 __70:
 	;
 
-	pos = pos + ((*FILE)(unsafe.Pointer((f))).shcnt + ((int64((*FILE)(unsafe.Pointer((f))).rpos) - int64((*FILE)(unsafe.Pointer((f))).buf)) / 1))
+	pos = pos + ((*FILE)(unsafe.Pointer(f)).shcnt + (int64((*FILE)(unsafe.Pointer(f)).rpos)-int64((*FILE)(unsafe.Pointer(f)).buf))/1)
 	if !(dest != 0) {
 		goto __149
 	}
@@ -6446,7 +6446,7 @@ __5:
 fmt_fail:
 alloc_fail:
 input_fail:
-	if !(!(matches != 0)) {
+	if !!(matches != 0) {
 		goto __151
 	}
 	matches--
@@ -6482,18 +6482,18 @@ __155:
 
 func string_read(tls *TLS, f uintptr, buf uintptr, len size_t) size_t { /* vsscanf.c:4:15: */
 	var src uintptr = (*FILE)(unsafe.Pointer(f)).cookie
-	var k size_t = (len + uint64(256))
+	var k size_t = len + uint64(256)
 	var end uintptr = Xmemchr(tls, src, 0, k)
 	if end != 0 {
-		k = (size_t((int64(end) - int64(src)) / 1))
+		k = size_t((int64(end) - int64(src)) / 1)
 	}
 	if k < len {
 		len = k
 	}
 	Xmemcpy(tls, buf, src, len)
-	(*FILE)(unsafe.Pointer(f)).rpos = (src + uintptr(len))
-	(*FILE)(unsafe.Pointer(f)).rend = (src + uintptr(k))
-	(*FILE)(unsafe.Pointer(f)).cookie = (src + uintptr(k))
+	(*FILE)(unsafe.Pointer(f)).rpos = src + uintptr(len)
+	(*FILE)(unsafe.Pointer(f)).rend = src + uintptr(k)
+	(*FILE)(unsafe.Pointer(f)).cookie = src + uintptr(k)
 	return len
 }
 
@@ -6504,7 +6504,7 @@ func Xvsscanf(tls *TLS, s uintptr, fmt uintptr, ap va_list) int32 { /* vsscanf.c
 	*(*FILE)(unsafe.Pointer(bp /* f */)) = FILE{read: *(*uintptr)(unsafe.Pointer(&struct {
 		f func(*TLS, uintptr, uintptr, size_t) size_t
 	}{string_read})), buf: s, lock: -1, cookie: s}
-	return Xvfscanf(tls, bp /* &f */, fmt, ap)
+	return Xvfscanf(tls, bp, fmt, ap)
 }
 
 func strtox(tls *TLS, s uintptr, p uintptr, prec int32) float64 { /* strtod.c:6:20: */
@@ -6513,15 +6513,15 @@ func strtox(tls *TLS, s uintptr, p uintptr, prec int32) float64 { /* strtod.c:6:
 
 	// var f FILE at bp, 232
 
-	(*FILE)(unsafe.Pointer(bp /* &f */)).buf = AssignPtrUintptr(bp /* &f */ +8 /* &.rpos */, s)
-	(*FILE)(unsafe.Pointer(bp /* &f */)).rend = UintptrFromInt32(-1)
-	X__shlim(tls, bp /* &f */, int64(0))
-	var y float64 = X__floatscan(tls, bp /* &f */, prec, 1)
-	var cnt off_t = ((*FILE)(unsafe.Pointer((bp /* &f */))).shcnt + ((int64((*FILE)(unsafe.Pointer((bp /* &f */))).rpos) - int64((*FILE)(unsafe.Pointer((bp /* &f */))).buf)) / 1))
+	(*FILE)(unsafe.Pointer(bp)).buf = AssignPtrUintptr(bp+8, s)
+	(*FILE)(unsafe.Pointer(bp)).rend = UintptrFromInt32(-1)
+	X__shlim(tls, bp, int64(0))
+	var y float64 = X__floatscan(tls, bp, prec, 1)
+	var cnt off_t = (*FILE)(unsafe.Pointer(bp)).shcnt + (int64((*FILE)(unsafe.Pointer(bp)).rpos)-int64((*FILE)(unsafe.Pointer(bp)).buf))/1
 	if p != 0 {
 		*(*uintptr)(unsafe.Pointer(p)) = func() uintptr {
 			if cnt != 0 {
-				return (s + uintptr(cnt))
+				return s + uintptr(cnt)
 			}
 			return s
 		}()
@@ -6547,31 +6547,31 @@ func strtox1(tls *TLS, s uintptr, p uintptr, base int32, lim uint64) uint64 { /*
 
 	// var f FILE at bp, 232
 
-	(*FILE)(unsafe.Pointer(bp /* &f */)).buf = AssignPtrUintptr(bp /* &f */ +8 /* &.rpos */, s)
-	(*FILE)(unsafe.Pointer(bp /* &f */)).rend = UintptrFromInt32(-1)
-	X__shlim(tls, bp /* &f */, int64(0))
-	var y uint64 = X__intscan(tls, bp /* &f */, uint32(base), 1, lim)
+	(*FILE)(unsafe.Pointer(bp)).buf = AssignPtrUintptr(bp+8, s)
+	(*FILE)(unsafe.Pointer(bp)).rend = UintptrFromInt32(-1)
+	X__shlim(tls, bp, int64(0))
+	var y uint64 = X__intscan(tls, bp, uint32(base), 1, lim)
 	if p != 0 {
-		var cnt size_t = (size_t((*FILE)(unsafe.Pointer((bp /* &f */))).shcnt + ((int64((*FILE)(unsafe.Pointer((bp /* &f */))).rpos) - int64((*FILE)(unsafe.Pointer((bp /* &f */))).buf)) / 1)))
-		*(*uintptr)(unsafe.Pointer(p)) = (s + uintptr(cnt))
+		var cnt size_t = size_t((*FILE)(unsafe.Pointer(bp)).shcnt + (int64((*FILE)(unsafe.Pointer(bp)).rpos)-int64((*FILE)(unsafe.Pointer(bp)).buf))/1)
+		*(*uintptr)(unsafe.Pointer(p)) = s + uintptr(cnt)
 	}
 	return y
 }
 
 func Xstrtoull(tls *TLS, s uintptr, p uintptr, base int32) uint64 { /* strtol.c:21:20: */
-	return strtox1(tls, s, p, base, ((2 * uint64(0x7fffffffffffffff)) + uint64(1)))
+	return strtox1(tls, s, p, base, 2*uint64(0x7fffffffffffffff)+uint64(1))
 }
 
 func Xstrtoll(tls *TLS, s uintptr, p uintptr, base int32) int64 { /* strtol.c:26:11: */
-	return int64(strtox1(tls, s, p, base, (Uint64FromInt64(-0x7fffffffffffffff - int64(1)))))
+	return int64(strtox1(tls, s, p, base, Uint64FromInt64(-0x7fffffffffffffff-int64(1))))
 }
 
 func Xstrtoul(tls *TLS, s uintptr, p uintptr, base int32) uint64 { /* strtol.c:31:15: */
-	return uint64(strtox1(tls, s, p, base, ((2 * uint64(0x7fffffffffffffff)) + uint64(1))))
+	return uint64(strtox1(tls, s, p, base, 2*uint64(0x7fffffffffffffff)+uint64(1)))
 }
 
 func Xstrtol(tls *TLS, s uintptr, p uintptr, base int32) int64 { /* strtol.c:36:6: */
-	return int64(strtox1(tls, s, p, base, (0 + (Uint64FromInt64(Int64(-Int64(0x7fffffffffffffff)) - Int64FromInt32(1))))))
+	return int64(strtox1(tls, s, p, base, 0+Uint64FromInt64(Int64(-Int64(0x7fffffffffffffff))-Int64FromInt32(1))))
 }
 
 func Xstrtoimax(tls *TLS, s uintptr, p uintptr, base int32) intmax_t { /* strtol.c:41:10: */
@@ -6584,19 +6584,19 @@ func Xstrtoumax(tls *TLS, s uintptr, p uintptr, base int32) uintmax_t { /* strto
 
 func Xstrdup(tls *TLS, s uintptr) uintptr { /* strdup.c:4:6: */
 	var l size_t = Xstrlen(tls, s)
-	var d uintptr = Xmalloc(tls, (l + uint64(1)))
+	var d uintptr = Xmalloc(tls, l+uint64(1))
 	if !(d != 0) {
 		return uintptr(0)
 	}
-	return Xmemcpy(tls, d, s, (l + uint64(1)))
+	return Xmemcpy(tls, d, s, l+uint64(1))
 }
 
 func Xstrlcat(tls *TLS, d uintptr, s uintptr, n size_t) size_t { /* strlcat.c:4:8: */
 	var l size_t = Xstrnlen(tls, d, n)
 	if l == n {
-		return (l + Xstrlen(tls, s))
+		return l + Xstrlen(tls, s)
 	}
-	return (l + Xstrlcpy(tls, (d+uintptr(l)), s, (n-l)))
+	return l + Xstrlcpy(tls, d+uintptr(l), s, n-l)
 }
 
 // Support signed or unsigned plain-char
@@ -6614,17 +6614,17 @@ func Xstrlcpy(tls *TLS, d uintptr, s uintptr, n size_t) size_t { /* strlcpy.c:11
 	var ws uintptr
 	d0 = d
 
-	if !(!(int32(PostDecUint64(&n, 1)) != 0)) {
+	if !!(int32(PostDecUint64(&n, 1)) != 0) {
 		goto __1
 	}
 	goto finish
 __1:
 	;
-	if !((uintptr_t(s) & (uint64(unsafe.Sizeof(size_t(0))) - uint64(1))) == (uintptr_t(d) & (uint64(unsafe.Sizeof(size_t(0))) - uint64(1)))) {
+	if !(uintptr_t(s)&(uint64(unsafe.Sizeof(size_t(0)))-uint64(1)) == uintptr_t(d)&(uint64(unsafe.Sizeof(size_t(0)))-uint64(1))) {
 		goto __2
 	}
 __3:
-	if !((((uintptr_t(s) & (uint64(unsafe.Sizeof(size_t(0))) - uint64(1))) != 0) && (n != 0)) && (AssignPtrInt8(d, *(*int8)(unsafe.Pointer(s))) != 0)) {
+	if !(uintptr_t(s)&(uint64(unsafe.Sizeof(size_t(0)))-uint64(1)) != 0 && n != 0 && AssignPtrInt8(d, *(*int8)(unsafe.Pointer(s))) != 0) {
 		goto __5
 	}
 	goto __4
@@ -6636,19 +6636,19 @@ __4:
 	goto __5
 __5:
 	;
-	if !((n != 0) && (*(*int8)(unsafe.Pointer(s)) != 0)) {
+	if !(n != 0 && *(*int8)(unsafe.Pointer(s)) != 0) {
 		goto __6
 	}
 	wd = d
 	ws = s
 __7:
-	if !((n >= size_t(unsafe.Sizeof(size_t(0)))) && !(((((*(*uint64)(unsafe.Pointer(ws))) - (Uint64(Uint64FromInt32(-1)) / uint64(255))) & ^(*(*uint64)(unsafe.Pointer(ws)))) & ((Uint64(Uint64FromInt32(-1)) / uint64(255)) * (uint64((255 / 2) + 1)))) != 0)) {
+	if !(n >= size_t(unsafe.Sizeof(size_t(0))) && !((*(*uint64)(unsafe.Pointer(ws))-Uint64(Uint64FromInt32(-1))/uint64(255)) & ^*(*uint64)(unsafe.Pointer(ws)) & (Uint64(Uint64FromInt32(-1))/uint64(255)*uint64(255/2+1)) != 0)) {
 		goto __9
 	}
 	*(*size_t)(unsafe.Pointer(wd)) = *(*uint64)(unsafe.Pointer(ws))
 	goto __8
 __8:
-	n = n - (size_t(unsafe.Sizeof(size_t(0))))
+	n = n - size_t(unsafe.Sizeof(size_t(0)))
 	ws += 8
 	wd += 8
 	goto __7
@@ -6662,7 +6662,7 @@ __6:
 __2:
 	;
 __10:
-	if !((n != 0) && (AssignPtrInt8(d, *(*int8)(unsafe.Pointer(s))) != 0)) {
+	if !(n != 0 && AssignPtrInt8(d, *(*int8)(unsafe.Pointer(s))) != 0) {
 		goto __12
 	}
 	goto __11
@@ -6676,7 +6676,7 @@ __12:
 	;
 	*(*int8)(unsafe.Pointer(d)) = int8(0)
 finish:
-	return ((size_t((int64(d) - int64(d0)) / 1)) + Xstrlen(tls, s))
+	return size_t((int64(d)-int64(d0))/1) + Xstrlen(tls, s)
 }
 
 func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n size_t) int32 { /* strncasecmp.c:4:5: */
@@ -6686,7 +6686,7 @@ func Xstrncasecmp(tls *TLS, _l uintptr, _r uintptr, n size_t) int32 { /* strncas
 		return 0
 	}
 __1:
-	if !((((*(*uint8)(unsafe.Pointer(l)) != 0) && (*(*uint8)(unsafe.Pointer(r)) != 0)) && (n != 0)) && ((int32(*(*uint8)(unsafe.Pointer(l))) == int32(*(*uint8)(unsafe.Pointer(r)))) || (Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(r))))))) {
+	if !(*(*uint8)(unsafe.Pointer(l)) != 0 && *(*uint8)(unsafe.Pointer(r)) != 0 && n != 0 && (int32(*(*uint8)(unsafe.Pointer(l))) == int32(*(*uint8)(unsafe.Pointer(r))) || Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(l)))) == Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(r)))))) {
 		goto __3
 	}
 	goto __2
@@ -6698,7 +6698,7 @@ __2:
 	goto __3
 __3:
 	;
-	return (Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(r)))))
+	return Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(l)))) - Xtolower(tls, int32(*(*uint8)(unsafe.Pointer(r))))
 }
 
 func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n size_t, loc locale_t) int32 { /* strncasecmp.c:12:5: */
@@ -6708,7 +6708,7 @@ func X__strncasecmp_l(tls *TLS, l uintptr, r uintptr, n size_t, loc locale_t) in
 func Xstrncat(tls *TLS, d uintptr, s uintptr, n size_t) uintptr { /* strncat.c:3:6: */
 	var a uintptr = d
 	d += uintptr(Xstrlen(tls, d))
-	for (n != 0) && (*(*int8)(unsafe.Pointer(s)) != 0) {
+	for n != 0 && *(*int8)(unsafe.Pointer(s)) != 0 {
 		n--
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&d, 1))) = *(*int8)(unsafe.Pointer(PostIncUintptr(&s, 1)))
 	}
@@ -6719,7 +6719,7 @@ func Xstrncat(tls *TLS, d uintptr, s uintptr, n size_t) uintptr { /* strncat.c:3
 func Xstrnlen(tls *TLS, s uintptr, n size_t) size_t { /* strnlen.c:3:8: */
 	var p uintptr = Xmemchr(tls, s, 0, n)
 	if p != 0 {
-		return (uint64((int64(p) - int64(s)) / 1))
+		return uint64((int64(p) - int64(s)) / 1)
 	}
 	return n
 }
@@ -6737,14 +6737,14 @@ func Xstrspn(tls *TLS, s uintptr, c uintptr) size_t { /* strspn.c:6:8: */
 	if !(int32(*(*int8)(unsafe.Pointer(c + 1))) != 0) {
 		for ; int32(*(*int8)(unsafe.Pointer(s))) == int32(*(*int8)(unsafe.Pointer(c))); s++ {
 		}
-		return (size_t((int64(s) - int64(a)) / 1))
+		return size_t((int64(s) - int64(a)) / 1)
 	}
 
-	for ; (*(*int8)(unsafe.Pointer(c)) != 0) && (AssignOrPtrUint64(bp /* &byteset */ +uintptr(((size_t(*(*uint8)(unsafe.Pointer(c))))/(uint64(8)*uint64(unsafe.Sizeof(size_t(0))))))*8, (size_t(uint64(1))<<((size_t(*(*uint8)(unsafe.Pointer(c))))%(uint64(8)*uint64(unsafe.Sizeof(size_t(0))))))) != 0); c++ {
+	for ; *(*int8)(unsafe.Pointer(c)) != 0 && AssignOrPtrUint64(bp+uintptr(size_t(*(*uint8)(unsafe.Pointer(c)))/(uint64(8)*uint64(unsafe.Sizeof(size_t(0)))))*8, size_t(uint64(1))<<(size_t(*(*uint8)(unsafe.Pointer(c)))%(uint64(8)*uint64(unsafe.Sizeof(size_t(0)))))) != 0; c++ {
 	}
-	for ; (*(*int8)(unsafe.Pointer(s)) != 0) && ((*(*size_t)(unsafe.Pointer(bp /* &byteset[0] */ + uintptr(((size_t(*(*uint8)(unsafe.Pointer(s))))/(uint64(8)*uint64(unsafe.Sizeof(size_t(0))))))*8)) & (size_t(uint64(1)) << ((size_t(*(*uint8)(unsafe.Pointer(s)))) % (uint64(8) * uint64(unsafe.Sizeof(size_t(0))))))) != 0); s++ {
+	for ; *(*int8)(unsafe.Pointer(s)) != 0 && *(*size_t)(unsafe.Pointer(bp + uintptr(size_t(*(*uint8)(unsafe.Pointer(s)))/(uint64(8)*uint64(unsafe.Sizeof(size_t(0)))))*8))&(size_t(uint64(1))<<(size_t(*(*uint8)(unsafe.Pointer(s)))%(uint64(8)*uint64(unsafe.Sizeof(size_t(0)))))) != 0; s++ {
 	}
-	return (size_t((int64(s) - int64(a)) / 1))
+	return size_t((int64(s) - int64(a)) / 1)
 }
 
 func Xstrtok(tls *TLS, s uintptr, sep uintptr) uintptr { /* strtok.c:3:6: */
@@ -6755,7 +6755,7 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) uintptr { /* strtok.c:3:6: */
 	if !(int32(*(*int8)(unsafe.Pointer(s))) != 0) {
 		return AssignPtrUintptr(uintptr(unsafe.Pointer(&_sp)), uintptr(0))
 	}
-	_sp = (s + uintptr(Xstrcspn(tls, s, sep)))
+	_sp = s + uintptr(Xstrcspn(tls, s, sep))
 	if *(*int8)(unsafe.Pointer(_sp)) != 0 {
 		*(*int8)(unsafe.Pointer(PostIncUintptr(&_sp, 1))) = int8(0)
 	} else {
@@ -6767,11 +6767,11 @@ func Xstrtok(tls *TLS, s uintptr, sep uintptr) uintptr { /* strtok.c:3:6: */
 var _sp uintptr /* strtok.c:5:14: */
 
 func X__ccgo_pthreadAttrGetDetachState(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:3:5: */
-	return *(*int32)(unsafe.Pointer((a /* &.__u */ /* &.__i */) + 6*4))
+	return *(*int32)(unsafe.Pointer(a + 6*4))
 }
 
 func Xpthread_attr_getdetachstate(tls *TLS, a uintptr, state uintptr) int32 { /* pthread_attr_get.c:7:5: */
-	*(*int32)(unsafe.Pointer(state)) = *(*int32)(unsafe.Pointer((a /* &.__u */ /* &.__i */) + 6*4))
+	*(*int32)(unsafe.Pointer(state)) = *(*int32)(unsafe.Pointer(a + 6*4))
 	return 0
 }
 
@@ -6857,7 +6857,7 @@ func Xpthread_attr_getdetachstate(tls *TLS, a uintptr, state uintptr) int32 { /*
 // }
 
 func X__ccgo_pthreadMutexattrGettype(tls *TLS, a uintptr) int32 { /* pthread_attr_get.c:93:5: */
-	return (int32((*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr & uint32(3)))
+	return int32((*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr & uint32(3))
 }
 
 // int pthread_mutexattr_gettype(const pthread_mutexattr_t *restrict a, int *restrict type)
@@ -6876,12 +6876,12 @@ func Xpthread_attr_setdetachstate(tls *TLS, a uintptr, state int32) int32 { /* p
 	if uint32(state) > 1 {
 		return 22
 	}
-	*(*int32)(unsafe.Pointer((a /* &.__u */ /* &.__i */) + 6*4)) = state
+	*(*int32)(unsafe.Pointer(a + 6*4)) = state
 	return 0
 }
 
 func X__ccgo_getMutexType(tls *TLS, m uintptr) int32 { /* pthread_mutex_lock.c:3:5: */
-	return (*(*int32)(unsafe.Pointer((m /* &.__u */ /* &.__i */))) & 15)
+	return *(*int32)(unsafe.Pointer(m)) & 15
 }
 
 // int __pthread_mutex_lock(pthread_mutex_t *m)
@@ -6908,12 +6908,12 @@ func Xpthread_mutexattr_settype(tls *TLS, a uintptr, type1 int32) int32 { /* pth
 	if uint32(type1) > uint32(2) {
 		return 22
 	}
-	(*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr = (((*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr & Uint32FromInt32(CplInt32(3))) | uint32(type1))
+	(*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr = (*pthread_mutexattr_t)(unsafe.Pointer(a)).__attr&Uint32FromInt32(CplInt32(3)) | uint32(type1)
 	return 0
 }
 
 func init() {
-	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&ptable)) + 0)) = (uintptr(unsafe.Pointer(&table)) + uintptr(128)*2) // __ctype_b_loc.c:36:45:
+	*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&ptable)) + 0)) = uintptr(unsafe.Pointer(&table)) + uintptr(128)*2 // __ctype_b_loc.c:36:45:
 }
 
 var ts1 = "infinity\x00nan\x00\x00\x00\x01\x02\x04\a\x03\x06\x05\x00.\x00%d.%d.%d.%d.in-addr.arpa\x00ip6.arpa\x000123456789abcdef\x00/etc/hosts\x00rb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00%d.%d.%d.%d\x00%x:%x:%x:%x:%x:%x:%x:%x\x00%x:%x:%x:%x:%x:%x:%d.%d.%d.%d\x00:0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00 \x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00 \x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"