Index: tests/builtins/sync.cfa
===================================================================
--- tests/builtins/sync.cfa	(revision c64e979e5a72d932eb71ffb6dc8d5798b3ff3fac)
+++ tests/builtins/sync.cfa	(revision 1712f542a5ea4d2772859a9d4ca18e5f865db7cb)
@@ -4,222 +4,160 @@
 void foo() {
 	volatile _Bool * vpB = 0; _Bool vB = 0;
-	volatile char * vp1 = 0; char * rp1 = 0; char v1 = 0;
-	volatile short * vp2 = 0; short * rp2 = 0; short v2 = 0;
-	volatile int * vp4 = 0; int * rp4 = 0; int v4 = 0;
-	volatile long long int * vp8 = 0; long long int * rp8 = 0; long long int v8 = 0;
-	#if defined(__SIZEOF_INT128__)
-	volatile __int128 * vp16 = 0; __int128 * rp16 = 0; __int128 v16 = 0;
+	volatile char * vpc = 0; char * rpc = 0; char vc = 0;
+	volatile short * vps = 0; short * rps = 0; short vs = 0;
+	volatile int * vpi = 0; int * rpi = 0; int vi = 0;
+	volatile long int * vpl = 0; long int * rpl = 0; long int vl = 0;
+	volatile long long int * vpll = 0; long long int * rpll = 0; long long int vll = 0;
+	#if defined(__SIZEOF_INT128__)
+	volatile __int128 * vplll = 0; __int128 * rplll = 0; __int128 vlll = 0;
 	#endif
 	struct type * volatile * vpp = 0; struct type ** rpp = 0; struct type * vp = 0;
 
-	{ char ret; ret = __sync_fetch_and_add(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_add_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_add(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_add_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_add(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_add_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_add(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_add_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_add(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_add_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_fetch_and_sub(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_sub_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_sub(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_sub_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_sub(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_sub_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_sub(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_sub_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_sub(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_sub_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_fetch_and_or(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_or_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_or(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_or_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_or(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_or_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_or(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_or_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_or(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_or_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_fetch_and_and(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_and_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_and(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_and_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_and(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_and_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_and(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_and_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_and(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_and_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_fetch_and_xor(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_xor_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_xor(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_xor_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_xor(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_xor_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_xor(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_xor_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_xor(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_xor_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_fetch_and_nand(vp1, v1); }
-	{ char ret; ret = __sync_fetch_and_nand_1(vp1, v1); }
-	{ short ret; ret = __sync_fetch_and_nand(vp2, v2); }
-	{ short ret; ret = __sync_fetch_and_nand_2(vp2, v2); }
-	{ int ret; ret = __sync_fetch_and_nand(vp4, v4); }
-	{ int ret; ret = __sync_fetch_and_nand_4(vp4, v4); }
-	{ long long int ret; ret = __sync_fetch_and_nand(vp8, v8); }
-	{ long long int ret; ret = __sync_fetch_and_nand_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_fetch_and_nand(vp16, v16); }
-	{ __int128 ret; ret = __sync_fetch_and_nand_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_add_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_add_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_add_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_add_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_add_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_add_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_add_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_add_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_add_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_add_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_sub_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_sub_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_sub_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_sub_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_sub_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_sub_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_sub_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_sub_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_sub_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_sub_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_or_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_or_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_or_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_or_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_or_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_or_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_or_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_or_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_or_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_or_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_and_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_and_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_and_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_and_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_and_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_and_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_and_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_and_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_and_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_and_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_xor_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_xor_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_xor_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_xor_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_xor_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_xor_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_xor_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_xor_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_xor_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_xor_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ char ret; ret = __sync_nand_and_fetch(vp1, v1); }
-	{ char ret; ret = __sync_nand_and_fetch_1(vp1, v1); }
-	{ short ret; ret = __sync_nand_and_fetch(vp2, v2); }
-	{ short ret; ret = __sync_nand_and_fetch_2(vp2, v2); }
-	{ int ret; ret = __sync_nand_and_fetch(vp4, v4); }
-	{ int ret; ret = __sync_nand_and_fetch_4(vp4, v4); }
-	{ long long int ret; ret = __sync_nand_and_fetch(vp8, v8); }
-	{ long long int ret; ret = __sync_nand_and_fetch_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_nand_and_fetch(vp16, v16); }
-	{ __int128 ret; ret = __sync_nand_and_fetch_16(vp16, v16); }
-	#endif
-
-	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp1, v1, v1); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap_1(vp1, v1, v1); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp2, v2, v2); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap_2(vp2, v2, v2); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp4, v4, v4); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap_4(vp4, v4, v4); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp8, v8, v8); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap_8(vp8, v8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ _Bool ret; ret = __sync_bool_compare_and_swap(vp16, v16, v16); }
-	{ _Bool ret; ret = __sync_bool_compare_and_swap_16(vp16, v16,v16); }
+	{ char ret; ret = __sync_fetch_and_add(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_add(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_add(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_add(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_add(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_add(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_fetch_and_sub(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_sub(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_sub(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_sub(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_sub(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_sub(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_fetch_and_or(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_or(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_or(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_or(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_or(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_or(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_fetch_and_and(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_and(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_and(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_and(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_and(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_and(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_fetch_and_xor(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_xor(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_xor(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_xor(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_xor(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_xor(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_fetch_and_nand(vpc, vc); }
+	{ short ret; ret = __sync_fetch_and_nand(vps, vs); }
+	{ int ret; ret = __sync_fetch_and_nand(vpi, vi); }
+	{ long int ret; ret = __sync_fetch_and_nand(vpl, vl); }
+	{ long long int ret; ret = __sync_fetch_and_nand(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_fetch_and_nand(vplll, vlll); }
+	{ __int128 ret; ret = __sync_fetch_and_nand_16(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_add_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_add_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_add_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_add_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_add_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_add_and_fetch(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_sub_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_sub_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_sub_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_sub_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_sub_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_sub_and_fetch(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_or_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_or_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_or_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_or_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_or_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_or_and_fetch(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_and_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_and_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_and_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_and_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_and_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_and_and_fetch(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_xor_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_xor_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_xor_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_xor_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_xor_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_xor_and_fetch(vplll, vlll); }
+	#endif
+
+	{ char ret; ret = __sync_nand_and_fetch(vpc, vc); }
+	{ short ret; ret = __sync_nand_and_fetch(vps, vs); }
+	{ int ret; ret = __sync_nand_and_fetch(vpi, vi); }
+	{ long int ret; ret = __sync_nand_and_fetch(vpl, vl); }
+	{ long long int ret; ret = __sync_nand_and_fetch(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_nand_and_fetch(vplll, vlll); }
+	#endif
+
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpc, vc, vc); }
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vps, vs, vs); }
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpi, vi, vi); }
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpl, vl, vl); }
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpll, vll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ _Bool ret; ret = __sync_bool_compare_and_swap(vplll, vlll, vlll); }
 	#endif
 	{ _Bool ret; ret = __sync_bool_compare_and_swap(vpp, vp, vp); }
 
-	{ char ret; ret = __sync_val_compare_and_swap(vp1, v1, v1); }
-	{ char ret; ret = __sync_val_compare_and_swap_1(vp1, v1, v1); }
-	{ short ret; ret = __sync_val_compare_and_swap(vp2, v2, v2); }
-	{ short ret; ret = __sync_val_compare_and_swap_2(vp2, v2, v2); }
-	{ int ret; ret = __sync_val_compare_and_swap(vp4, v4, v4); }
-	{ int ret; ret = __sync_val_compare_and_swap_4(vp4, v4, v4); }
-	{ long long int ret; ret = __sync_val_compare_and_swap(vp8, v8, v8); }
-	{ long long int ret; ret = __sync_val_compare_and_swap_8(vp8, v8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_val_compare_and_swap(vp16, v16, v16); }
-	{ __int128 ret; ret = __sync_val_compare_and_swap_16(vp16, v16,v16); }
+	{ char ret; ret = __sync_val_compare_and_swap(vpc, vc, vc); }
+	{ short ret; ret = __sync_val_compare_and_swap(vps, vs, vs); }
+	{ int ret; ret = __sync_val_compare_and_swap(vpi, vi, vi); }
+	{ long int ret; ret = __sync_val_compare_and_swap(vpl, vl, vl); }
+	{ long long int ret; ret = __sync_val_compare_and_swap(vpll, vll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_val_compare_and_swap(vplll, vlll, vlll); }
 	#endif
 	{ struct type * ret; ret = __sync_val_compare_and_swap(vpp, vp, vp); }
 
 
-	{ char ret; ret = __sync_lock_test_and_set(vp1, v1); }
-	{ char ret; ret = __sync_lock_test_and_set_1(vp1, v1); }
-	{ short ret; ret = __sync_lock_test_and_set(vp2, v2); }
-	{ short ret; ret = __sync_lock_test_and_set_2(vp2, v2); }
-	{ int ret; ret = __sync_lock_test_and_set(vp4, v4); }
-	{ int ret; ret = __sync_lock_test_and_set_4(vp4, v4); }
-	{ long long int ret; ret = __sync_lock_test_and_set(vp8, v8); }
-	{ long long int ret; ret = __sync_lock_test_and_set_8(vp8, v8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __sync_lock_test_and_set(vp16, v16); }
-	{ __int128 ret; ret = __sync_lock_test_and_set_16(vp16, v16); }
-	#endif
-
-	{ __sync_lock_release(vp1); }
-	{ __sync_lock_release_1(vp1); }
-	{ __sync_lock_release(vp2); }
-	{ __sync_lock_release_2(vp2); }
-	{ __sync_lock_release(vp4); }
-	{ __sync_lock_release_4(vp4); }
-	{ __sync_lock_release(vp8); }
-	{ __sync_lock_release_8(vp8); }
-	#if defined(__SIZEOF_INT128__)
-	{ __sync_lock_release(vp16); }
-	{ __sync_lock_release_16(vp16); }
+	{ char ret; ret = __sync_lock_test_and_set(vpc, vc); }
+	{ short ret; ret = __sync_lock_test_and_set(vps, vs); }
+	{ int ret; ret = __sync_lock_test_and_set(vpi, vi); }
+	{ long int ret; ret = __sync_lock_test_and_set(vpl, vl); }
+	{ long long int ret; ret = __sync_lock_test_and_set(vpll, vll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __sync_lock_test_and_set(vplll, vlll); }
+	#endif
+
+	{ __sync_lock_release(vpc); }
+	{ __sync_lock_release(vps); }
+	{ __sync_lock_release(vpi); }
+	{ __sync_lock_release(vpl); }
+	{ __sync_lock_release(vpll); }
+	#if defined(__SIZEOF_INT128__)
+	{ __sync_lock_release(vplll); }
 	#endif
 
@@ -230,246 +168,186 @@
 
 	{ _Bool ret; ret = __atomic_test_and_set(vpB, vB); }
-	{ _Bool ret; ret = __atomic_test_and_set(vp1, v1); }
+	{ _Bool ret; ret = __atomic_test_and_set(vpc, vc); }
 	{ __atomic_clear(vpB, vB); }
-	{ __atomic_clear(vp1, v1); }
-
-	{ char ret; ret = __atomic_exchange_n(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_exchange_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; __atomic_exchange(vp1, &v1, &ret, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_exchange_n(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_exchange_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; __atomic_exchange(vp2, &v2, &ret, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_exchange_n(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_exchange_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; __atomic_exchange(vp4, &v4, &ret, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_exchange_n(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_exchange_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; __atomic_exchange(vp8, &v8, &ret, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_exchange_n(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_exchange_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; __atomic_exchange(vp16, &v16, &ret, __ATOMIC_SEQ_CST); }
+	{ __atomic_clear(vpc, vc); }
+
+	{ char ret; ret = __atomic_exchange_n(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ char ret; __atomic_exchange(vpc, &vc, &ret, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_exchange_n(vps, vs, __ATOMIC_SEQ_CST); }
+	{ short ret; __atomic_exchange(vps, &vs, &ret, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_exchange_n(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ int ret; __atomic_exchange(vpi, &vi, &ret, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_exchange_n(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long int ret; __atomic_exchange(vpl, &vl, &ret, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_exchange_n(vpll, vll, __ATOMIC_SEQ_CST); }
+	{ long long int ret; __atomic_exchange(vpll, &vll, &ret, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_exchange_n(vplll, vlll, __ATOMIC_SEQ_CST); }
+	{ __int128 ret; __atomic_exchange(vplll, &vlll, &ret, __ATOMIC_SEQ_CST); }
 	#endif
 	{ struct type * ret; ret = __atomic_exchange_n(vpp, vp, __ATOMIC_SEQ_CST); }
 	{ struct type * ret; __atomic_exchange(vpp, &vp, &ret, __ATOMIC_SEQ_CST); }
 
-	{ char ret; ret = __atomic_load_n(vp1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_load_1(vp1, __ATOMIC_SEQ_CST); }
-	{ char ret; __atomic_load(vp1, &ret, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_load_n(vp2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_load_2(vp2, __ATOMIC_SEQ_CST); }
-	{ short ret; __atomic_load(vp2, &ret, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_load_n(vp4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_load_4(vp4, __ATOMIC_SEQ_CST); }
-	{ int ret; __atomic_load(vp4, &ret, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_load_n(vp8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_load_8(vp8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; __atomic_load(vp8, &ret, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_load_n(vp16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_load_16(vp16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; __atomic_load(vp16, &ret, __ATOMIC_SEQ_CST); }
+	{ char ret; ret = __atomic_load_n(vpc, __ATOMIC_SEQ_CST); }
+	{ char ret; __atomic_load(vpc, &ret, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_load_n(vps, __ATOMIC_SEQ_CST); }
+	{ short ret; __atomic_load(vps, &ret, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_load_n(vpi, __ATOMIC_SEQ_CST); }
+	{ int ret; __atomic_load(vpi, &ret, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_load_n(vpl, __ATOMIC_SEQ_CST); }
+	{ long int ret; __atomic_load(vpl, &ret, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_load_n(vpll, __ATOMIC_SEQ_CST); }
+	{ long long int ret; __atomic_load(vpll, &ret, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_load_n(vplll, __ATOMIC_SEQ_CST); }
+	{ __int128 ret; __atomic_load(vplll, &ret, __ATOMIC_SEQ_CST); }
 	#endif
 	{ struct type * ret; ret = __atomic_load_n(vpp, __ATOMIC_SEQ_CST); }
 	{ struct type * ret; __atomic_load(vpp, &ret, __ATOMIC_SEQ_CST); }
 
-	{ _Bool ret; ret = __atomic_compare_exchange_n(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_1(vp1, rp1, v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange(vp1, rp1, &v1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_n(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_2(vp2, rp2, v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange(vp2, rp2, &v2, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_n(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_4(vp4, rp4, v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange(vp4, rp4, &v4, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_n(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_8(vp8, rp8, v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange(vp8, rp8, &v8, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ _Bool ret; ret = __atomic_compare_exchange_n(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange_16(vp16, rp16, v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
-	{ _Bool ret; ret = __atomic_compare_exchange(vp16, rp16, &v16, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vpc, rpc, vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vpc, rpc, &vc, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vps, rps, vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vps, rps, &vs, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vpi, rpi, vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vpi, rpi, &vi, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vpl, rpl, vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vpl, rpl, &vl, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vpll, rpll, vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vpll, rpll, &vll, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ _Bool ret; ret = __atomic_compare_exchange_n(vplll, rplll, vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
+	{ _Bool ret; ret = __atomic_compare_exchange(vplll, rplll, &vlll, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 	#endif
 	{ _Bool ret; ret = __atomic_compare_exchange_n(vpp, rpp, vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 	{ _Bool ret; ret = __atomic_compare_exchange(vpp, rpp, &vp, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
 
-	{ __atomic_store_n(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ __atomic_store(vp1, &v1, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_n(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ __atomic_store(vp2, &v2, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_n(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ __atomic_store(vp4, &v4, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_n(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ __atomic_store(vp8, &v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __atomic_store_n(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __atomic_store_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __atomic_store(vp16, &v16, __ATOMIC_SEQ_CST); }
+	{ __atomic_store_n(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vpc, &vc, __ATOMIC_SEQ_CST); }
+	{ __atomic_store_n(vps, vs, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vps, &vs, __ATOMIC_SEQ_CST); }
+	{ __atomic_store_n(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vpi, &vi, __ATOMIC_SEQ_CST); }
+	{ __atomic_store_n(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vpl, &vl, __ATOMIC_SEQ_CST); }
+	{ __atomic_store_n(vpll, vll, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vpll, &vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __atomic_store_n(vplll, vlll, __ATOMIC_SEQ_CST); }
+	{ __atomic_store(vplll, &vlll, __ATOMIC_SEQ_CST); }
 	#endif
 	{ __atomic_store_n(vpp, vp, __ATOMIC_SEQ_CST); }
 	{ __atomic_store(vpp, &vp, __ATOMIC_SEQ_CST); }
 
-	{ char ret; ret = __atomic_add_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_add_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_add_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_add_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_add_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_add_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_add_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_add_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_add_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_add_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_sub_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_sub_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_sub_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_sub_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_sub_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_sub_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_sub_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_sub_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_sub_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_sub_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_and_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_and_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_and_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_and_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_and_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_and_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_and_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_and_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_and_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_and_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_nand_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_nand_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_nand_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_nand_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_nand_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_nand_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_nand_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_nand_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_nand_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_nand_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_xor_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_xor_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_xor_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_xor_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_xor_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_xor_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_xor_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_xor_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_xor_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_xor_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_or_fetch(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_or_fetch_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_or_fetch(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_or_fetch_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_or_fetch(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_or_fetch_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_or_fetch(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_or_fetch_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_or_fetch(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_or_fetch_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_add(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_add_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_add(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_add_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_add(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_add_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_add(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_add_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_add(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_add_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_sub(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_sub_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_sub(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_sub_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_sub(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_sub_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_sub(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_sub_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_sub(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_sub_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_and(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_and_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_and(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_and_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_and(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_and_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_and(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_and_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_and(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_and_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_nand(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_nand_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_nand(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_nand_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_nand(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_nand_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_nand(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_nand_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_nand(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_nand_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_xor(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_xor_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_xor(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_xor_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_xor(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_xor_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_xor(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_xor_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_xor(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_xor_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ char ret; ret = __atomic_fetch_or(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ char ret; ret = __atomic_fetch_or_1(vp1, v1, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_or(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ short ret; ret = __atomic_fetch_or_2(vp2, v2, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_or(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ int ret; ret = __atomic_fetch_or_4(vp4, v4, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_or(vp8, v8, __ATOMIC_SEQ_CST); }
-	{ long long int ret; ret = __atomic_fetch_or_8(vp8, v8, __ATOMIC_SEQ_CST); }
-	#if defined(__SIZEOF_INT128__)
-	{ __int128 ret; ret = __atomic_fetch_or(vp16, v16, __ATOMIC_SEQ_CST); }
-	{ __int128 ret; ret = __atomic_fetch_or_16(vp16, v16, __ATOMIC_SEQ_CST); }
-	#endif
-
-	{ _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vp4); }
-	{ _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vp4); }
+	{ char ret; ret = __atomic_add_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_add_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_add_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_add_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_add_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_add_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_sub_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_sub_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_sub_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_sub_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_sub_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_sub_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_and_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_and_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_and_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_and_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_and_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_and_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_nand_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_nand_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_nand_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_nand_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_nand_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_nand_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_xor_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_xor_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_xor_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_xor_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_xor_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_xor_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_or_fetch(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_or_fetch(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_or_fetch(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_or_fetch(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_or_fetch(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_or_fetch(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_add(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_add(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_add(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_add(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_add(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_add(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_sub(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_sub(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_sub(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_sub(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_sub(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_sub(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_and(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_and(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_and(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_and(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_and(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_and(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_nand(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_nand(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_nand(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_nand(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_nand(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_nand(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_xor(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_xor(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_xor(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_xor(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_xor(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_xor(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ char ret; ret = __atomic_fetch_or(vpc, vc, __ATOMIC_SEQ_CST); }
+	{ short ret; ret = __atomic_fetch_or(vps, vs, __ATOMIC_SEQ_CST); }
+	{ int ret; ret = __atomic_fetch_or(vpi, vi, __ATOMIC_SEQ_CST); }
+	{ long int ret; ret = __atomic_fetch_or(vpl, vl, __ATOMIC_SEQ_CST); }
+	{ long long int ret; ret = __atomic_fetch_or(vpll, vll, __ATOMIC_SEQ_CST); }
+	#if defined(__SIZEOF_INT128__)
+	{ __int128 ret; ret = __atomic_fetch_or(vplll, vlll, __ATOMIC_SEQ_CST); }
+	#endif
+
+	{ _Bool ret; ret = __atomic_always_lock_free(sizeof(int), vpi); }
+	{ _Bool ret; ret = __atomic_is_lock_free(sizeof(int), vpi); }
 	{ __atomic_thread_fence(__ATOMIC_SEQ_CST); }
 	{ __atomic_signal_fence(__ATOMIC_SEQ_CST); }