early-access version 2532

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 2531.
+This is the source code for early-access 2532.
 
 ## Legal Notice
 

src/core/hle/kernel/k_page_table.cpp

@@ -297,16 +297,15 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
     KMemoryState src_state{};
     KMemoryPermission src_perm{};
     std::size_t num_src_allocator_blocks{};
-    R_TRY(this->CheckMemoryState(std::addressof(src_state), std::addressof(src_perm), nullptr,
+    R_TRY(this->CheckMemoryState(&src_state, &src_perm, nullptr, &num_src_allocator_blocks,
-                                 std::addressof(num_src_allocator_blocks), src_address, size,
+                                 src_address, size, KMemoryState::All, KMemoryState::Normal,
-                                 KMemoryState::All, KMemoryState::Normal, KMemoryPermission::All,
+                                 KMemoryPermission::All, KMemoryPermission::UserReadWrite,
-                                 KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
+                                 KMemoryAttribute::All, KMemoryAttribute::None));
-                                 KMemoryAttribute::None));
 
     // Verify that the destination memory is unmapped.
     std::size_t num_dst_allocator_blocks{};
-    R_TRY(this->CheckMemoryState(std::addressof(num_dst_allocator_blocks), dst_address, size,
+    R_TRY(this->CheckMemoryState(&num_dst_allocator_blocks, dst_address, size, KMemoryState::All,
-                                 KMemoryState::All, KMemoryState::Free, KMemoryPermission::None,
+                                 KMemoryState::Free, KMemoryPermission::None,
                                  KMemoryPermission::None, KMemoryAttribute::None,
                                  KMemoryAttribute::None));
 
@@ -320,8 +319,8 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
         AddRegionToPages(src_address, num_pages, pg);
 
         // Reprotect the source as kernel-read/not mapped.
-        const KMemoryPermission new_perm = static_cast<KMemoryPermission>(
+        const auto new_perm = static_cast<KMemoryPermission>(KMemoryPermission::KernelRead |
-            KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
+                                                             KMemoryPermission::NotMapped);
         R_TRY(Operate(src_address, num_pages, new_perm, OperationType::ChangePermissions));
 
         // Ensure that we unprotect the source pages on failure.

src/shader_recompiler/frontend/maxwell/translate/impl/logic_operation_three_input.cpp

@@ -20,31 +20,31 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 1:
         return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, c)));
     case 2:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 3:
         return ir.BitwiseNot(ir.BitwiseOr(a, b));
     case 4:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)))));
+        return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 5:
         return ir.BitwiseNot(ir.BitwiseOr(a, c));
     case 6:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseXor(b, c))));
+        return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
     case 7:
         return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, c)));
     case 8:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, c))));
+        return ir.BitwiseAnd(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
     case 9:
         return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseXor(b, c)));
     case 10:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(c, ir.BitwiseNot(a));
     case 11:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 12:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)));
+        return ir.BitwiseAnd(b, ir.BitwiseNot(a));
     case 13:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)))));
+        return ir.BitwiseAnd(ir.BitwiseNot(a), ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 14:
-        return ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
     case 15:
         return ir.BitwiseNot(a);
     case 16:
@@ -52,146 +52,144 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 17:
         return ir.BitwiseNot(ir.BitwiseOr(b, c));
     case 18:
-        return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseXor(a, c))));
+        return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseXor(a, c));
     case 19:
         return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, c)));
     case 20:
-        return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseXor(a, b))));
+        return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseXor(a, b));
     case 21:
         return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
     case 22:
-        return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)));
+        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
     case 23:
-        return ir.BitwiseNot(
+        return ir.BitwiseXor(ir.BitwiseNot(a),
-            ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))));
+                             ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
     case 24:
         return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
     case 25:
         return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c)));
     case 26:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
+        return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 27:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 28:
-        return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, c)));
+        return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 29:
-        return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c)));
+        return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
     case 30:
         return ir.BitwiseXor(a, ir.BitwiseOr(b, c));
     case 31:
         return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, c)));
     case 32:
-        return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
     case 33:
         return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseXor(a, c)));
     case 34:
-        return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(c, ir.BitwiseNot(b));
     case 35:
-        return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 36:
-        return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(b, c));
     case 37:
         return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c)));
     case 38:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
+        return ir.BitwiseAnd(ir.BitwiseXor(b, c), ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 39:
         return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 40:
         return ir.BitwiseAnd(c, ir.BitwiseXor(a, b));
     case 41:
-        return ir.BitwiseXor(a,
+        return ir.BitwiseXor(ir.BitwiseOr(a, b),
-                             ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
+                             ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(c)));
     case 42:
         return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)));
     case 43:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseOr(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)),
-            a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))));
+                            ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 44:
-        return ir.BitwiseAnd(ir.BitwiseXor(a, b),
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b));
-                             ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))));
     case 45:
         return ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 46:
         return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c));
     case 47:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseAnd(c, ir.BitwiseNot(b)));
     case 48:
         return ir.BitwiseAnd(a, ir.BitwiseNot(b));
     case 49:
-        return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))));
+        return ir.BitwiseAnd(ir.BitwiseNot(b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 50:
-        return ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
     case 51:
         return ir.BitwiseNot(b);
     case 52:
         return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 53:
-        return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c)));
+        return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 54:
         return ir.BitwiseXor(b, ir.BitwiseOr(a, c));
     case 55:
         return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, c)));
     case 56:
-        return ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, c));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, b));
     case 57:
         return ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 58:
         return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c));
     case 59:
-        return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseAnd(c, ir.BitwiseNot(a)));
     case 60:
         return ir.BitwiseXor(a, b);
     case 61:
         return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 62:
-        return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(c, ir.BitwiseNot(a)));
     case 63:
         return ir.BitwiseNot(ir.BitwiseAnd(a, b));
     case 64:
-        return ir.BitwiseAnd(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
     case 65:
         return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseXor(a, b)));
     case 66:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
+        return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseXor(b, c));
     case 67:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, c)));
+        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, b)));
     case 68:
         return ir.BitwiseAnd(b, ir.BitwiseNot(c));
     case 69:
-        return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b))));
+        return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 70:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c))));
+        return ir.BitwiseAnd(ir.BitwiseXor(b, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 71:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 72:
         return ir.BitwiseAnd(b, ir.BitwiseXor(a, c));
     case 73:
-        return ir.BitwiseXor(a,
+        return ir.BitwiseXor(ir.BitwiseOr(a, c),
-                             ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c))));
+                             ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(b)));
     case 74:
-        return ir.BitwiseAnd(ir.BitwiseXor(a, c),
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c));
-                             ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))));
     case 75:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(a, ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 76:
         return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)));
     case 77:
-        return ir.BitwiseXor(a,
+        return ir.BitwiseOr(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)),
-                             ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
+                            ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 78:
         return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c));
     case 79:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)))));
+        return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseAnd(b, ir.BitwiseNot(c)));
     case 80:
         return ir.BitwiseAnd(a, ir.BitwiseNot(c));
     case 81:
-        return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))));
+        return ir.BitwiseAnd(ir.BitwiseNot(c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
     case 82:
         return ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
     case 83:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 84:
-        return ir.BitwiseNot(ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b))));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
     case 85:
         return ir.BitwiseNot(c);
     case 86:
@@ -205,82 +203,80 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 90:
         return ir.BitwiseXor(a, c);
     case 91:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
+        return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 92:
-        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, c));
+        return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(a, b));
     case 93:
-        return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b))));
+        return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
     case 94:
-        return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b))));
+        return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
     case 95:
         return ir.BitwiseNot(ir.BitwiseAnd(a, c));
     case 96:
         return ir.BitwiseAnd(a, ir.BitwiseXor(b, c));
     case 97:
-        return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)),
+        return ir.BitwiseXor(ir.BitwiseOr(b, c),
-                                              ir.BitwiseNot(ir.BitwiseXor(b, c))));
+                             ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(a)));
     case 98:
         return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c));
     case 99:
-        return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseAnd(a, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(b, ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 100:
         return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c));
     case 101:
-        return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b))));
+        return ir.BitwiseXor(c, ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 102:
         return ir.BitwiseXor(b, c);
     case 103:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
+        return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 104:
-        return ir.BitwiseXor(a,
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
-                             ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c))));
     case 105:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
+        return ir.BitwiseXor(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
     case 106:
         return ir.BitwiseXor(c, ir.BitwiseAnd(a, b));
     case 107:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
-            ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c))));
+                            ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
     case 108:
         return ir.BitwiseXor(b, ir.BitwiseAnd(a, c));
     case 109:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, c)),
-            ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c))));
+                            ir.BitwiseXor(b, ir.BitwiseAnd(a, c)));
     case 110:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseAnd(b, ir.BitwiseNot(a)));
-            ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseNot(ir.BitwiseXor(b, c))));
     case 111:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseXor(b, c))));
+        return ir.BitwiseOr(ir.BitwiseNot(a), ir.BitwiseXor(b, c));
     case 112:
         return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c)));
     case 113:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)),
-            ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c))));
+                            ir.BitwiseNot(ir.BitwiseOr(b, c)));
     case 114:
-        return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseAnd(b, c));
+        return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseOr(a, c));
     case 115:
-        return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)))));
+        return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
     case 116:
-        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, c));
+        return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseOr(a, b));
     case 117:
-        return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)))));
+        return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
     case 118:
-        return ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c));
+        return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
     case 119:
         return ir.BitwiseNot(ir.BitwiseAnd(b, c));
     case 120:
         return ir.BitwiseXor(a, ir.BitwiseAnd(b, c));
     case 121:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(b, c)),
-            a, ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c))));
+                            ir.BitwiseXor(a, ir.BitwiseAnd(b, c)));
     case 122:
         return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b)));
     case 123:
-        return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseXor(a, c))));
+        return ir.BitwiseOr(ir.BitwiseNot(b), ir.BitwiseXor(a, c));
     case 124:
         return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
     case 125:
-        return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseXor(a, b))));
+        return ir.BitwiseOr(ir.BitwiseNot(c), ir.BitwiseXor(a, b));
     case 126:
         return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c));
     case 127:
@@ -290,55 +286,54 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 129:
         return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
     case 130:
-        return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseXor(a, b)));
+        return ir.BitwiseAnd(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 131:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(c, ir.BitwiseNot(a)), ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 132:
-        return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseAnd(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 133:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseAnd(a, ir.BitwiseNot(b))));
+        return ir.BitwiseAnd(ir.BitwiseOr(b, ir.BitwiseNot(a)), ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 134:
-        return ir.BitwiseXor(a,
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
-                             ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)));
     case 135:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(b, c)));
+        return ir.BitwiseXor(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
     case 136:
         return ir.BitwiseAnd(b, c);
     case 137:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseAnd(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(b, ir.BitwiseNot(a)), ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 138:
-        return ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b))));
+        return ir.BitwiseAnd(c, ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 139:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 140:
-        return ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(b, ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 141:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseAnd(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 142:
         return ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
     case 143:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, c))));
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseNot(a));
     case 144:
-        return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 145:
-        return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 146:
-        return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
     case 147:
-        return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseAnd(a, c)));
+        return ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
     case 148:
-        return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
     case 149:
-        return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseAnd(a, b)));
+        return ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
     case 150:
         return ir.BitwiseXor(a, ir.BitwiseXor(b, c));
     case 151:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseOr(ir.BitwiseNot(ir.BitwiseOr(a, b)),
-            a, ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
+                            ir.BitwiseXor(a, ir.BitwiseXor(b, c)));
     case 152:
-        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 153:
-        return ir.BitwiseNot(ir.BitwiseXor(b, c));
+        return ir.BitwiseXor(b, ir.BitwiseNot(c));
     case 154:
         return ir.BitwiseXor(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
     case 155:
@@ -348,139 +343,129 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 157:
         return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(b, c)));
     case 158:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)),
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseOr(b, c)));
-                                                            ir.BitwiseNot(ir.BitwiseXor(b, c)))));
     case 159:
         return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseXor(b, c)));
     case 160:
         return ir.BitwiseAnd(a, c);
     case 161:
-        return ir.BitwiseNot(
+        return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(b)), ir.BitwiseXor(a, ir.BitwiseNot(c)));
-            ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b)))));
     case 162:
         return ir.BitwiseAnd(c, ir.BitwiseOr(a, ir.BitwiseNot(b)));
     case 163:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 164:
-        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 165:
-        return ir.BitwiseNot(ir.BitwiseXor(a, c));
+        return ir.BitwiseXor(a, ir.BitwiseNot(c));
     case 166:
-        return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseOr(a, ir.BitwiseNot(b))));
+        return ir.BitwiseXor(c, ir.BitwiseAnd(b, ir.BitwiseNot(a)));
     case 167:
         return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseXor(a, c)));
     case 168:
         return ir.BitwiseAnd(c, ir.BitwiseOr(a, b));
     case 169:
-        return ir.BitwiseNot(ir.BitwiseXor(c, ir.BitwiseOr(a, b)));
+        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
     case 170:
         return c;
     case 171:
         return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, b)));
     case 172:
-        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(a, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(a)));
     case 173:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseOr(a, ir.BitwiseNot(b))));
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 174:
-        return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(b))));
+        return ir.BitwiseOr(c, ir.BitwiseAnd(b, ir.BitwiseNot(a)));
     case 175:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)));
+        return ir.BitwiseOr(c, ir.BitwiseNot(a));
     case 176:
-        return ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(a, ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 177:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, c), ir.BitwiseOr(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseOr(b, c)));
     case 178:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseXor(b, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
-            a, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)))));
     case 179:
-        return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(ir.BitwiseAnd(a, c))));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(b));
     case 180:
         return ir.BitwiseXor(a, ir.BitwiseAnd(b, ir.BitwiseNot(c)));
     case 181:
-        return ir.BitwiseNot(
+        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, c)));
-            ir.BitwiseAnd(ir.BitwiseXor(a, c), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)))));
     case 182:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(b, ir.BitwiseOr(a, c)));
-            a, ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
     case 183:
         return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseXor(a, c)));
     case 184:
-        return ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseAnd(b, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseNot(b)));
     case 185:
-        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 186:
         return ir.BitwiseOr(c, ir.BitwiseAnd(a, ir.BitwiseNot(b)));
     case 187:
-        return ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c)));
+        return ir.BitwiseOr(c, ir.BitwiseNot(b));
     case 188:
-        return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseAnd(a, c));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, b));
     case 189:
-        return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 190:
         return ir.BitwiseOr(c, ir.BitwiseXor(a, b));
     case 191:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseAnd(a, b)));
     case 192:
         return ir.BitwiseAnd(a, b);
     case 193:
-        return ir.BitwiseNot(
+        return ir.BitwiseAnd(ir.BitwiseOr(a, ir.BitwiseNot(c)), ir.BitwiseXor(a, ir.BitwiseNot(b)));
-            ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c)))));
     case 194:
-        return ir.BitwiseNot(ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 195:
-        return ir.BitwiseNot(ir.BitwiseXor(a, b));
+        return ir.BitwiseXor(a, ir.BitwiseNot(b));
     case 196:
         return ir.BitwiseAnd(b, ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 197:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 198:
-        return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(b, ir.BitwiseAnd(c, ir.BitwiseNot(a)));
     case 199:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, c)));
+        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseXor(a, b)));
     case 200:
         return ir.BitwiseAnd(b, ir.BitwiseOr(a, c));
     case 201:
-        return ir.BitwiseNot(ir.BitwiseXor(b, ir.BitwiseOr(a, c)));
+        return ir.BitwiseXor(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
     case 202:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(a)));
     case 203:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(ir.BitwiseAnd(b, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 204:
         return b;
     case 205:
         return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, c)));
     case 206:
-        return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseOr(a, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(b, ir.BitwiseAnd(c, ir.BitwiseNot(a)));
     case 207:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(b)));
+        return ir.BitwiseOr(b, ir.BitwiseNot(a));
     case 208:
         return ir.BitwiseAnd(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 209:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseOr(b, c)));
     case 210:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseXor(a, ir.BitwiseAnd(c, ir.BitwiseNot(b)));
     case 211:
-        return ir.BitwiseNot(
+        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseXor(a, b)));
-            ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(c)))));
     case 212:
-        return ir.BitwiseXor(
+        return ir.BitwiseXor(c, ir.BitwiseOr(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
-            a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
     case 213:
-        return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseNot(ir.BitwiseAnd(a, b))));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(c));
     case 214:
-        return ir.BitwiseNot(ir.BitwiseXor(
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(c, ir.BitwiseOr(a, b)));
-            a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)))));
     case 215:
         return ir.BitwiseNot(ir.BitwiseAnd(c, ir.BitwiseXor(a, b)));
     case 216:
         return ir.BitwiseAnd(ir.BitwiseOr(a, c), ir.BitwiseOr(b, ir.BitwiseNot(c)));
     case 217:
-        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 218:
         return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, c));
     case 219:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseXor(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
-            ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c))));
     case 220:
         return ir.BitwiseOr(b, ir.BitwiseAnd(a, ir.BitwiseNot(c)));
     case 221:
@@ -488,47 +473,46 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 222:
         return ir.BitwiseOr(b, ir.BitwiseXor(a, c));
     case 223:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c)))));
+        return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseAnd(a, c)));
     case 224:
         return ir.BitwiseAnd(a, ir.BitwiseOr(b, c));
     case 225:
-        return ir.BitwiseNot(ir.BitwiseXor(a, ir.BitwiseOr(b, c)));
+        return ir.BitwiseXor(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
     case 226:
-        return ir.BitwiseNot(ir.BitwiseXor(ir.BitwiseAnd(a, b), ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(b)));
     case 227:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
-            ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseNot(ir.BitwiseAnd(a, c))));
     case 228:
-        return ir.BitwiseOr(ir.BitwiseAnd(a, c), ir.BitwiseAnd(b, ir.BitwiseNot(c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(b, c), ir.BitwiseOr(a, ir.BitwiseNot(c)));
     case 229:
-        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 230:
         return ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c));
     case 231:
-        return ir.BitwiseNot(ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
+        return ir.BitwiseOr(ir.BitwiseXor(b, c), ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 232:
-        return ir.BitwiseXor(a, ir.BitwiseAnd(ir.BitwiseXor(a, b), ir.BitwiseXor(a, c)));
+        return ir.BitwiseAnd(ir.BitwiseOr(a, b), ir.BitwiseOr(c, ir.BitwiseAnd(a, b)));
     case 233:
-        return ir.BitwiseNot(
+        return ir.BitwiseOr(ir.BitwiseAnd(a, b),
-            ir.BitwiseXor(a, ir.BitwiseOr(ir.BitwiseAnd(a, b), ir.BitwiseXor(b, c))));
+                            ir.BitwiseXor(ir.BitwiseOr(a, b), ir.BitwiseNot(c)));
     case 234:
         return ir.BitwiseOr(c, ir.BitwiseAnd(a, b));
     case 235:
-        return ir.BitwiseOr(c, ir.BitwiseNot(ir.BitwiseXor(a, b)));
+        return ir.BitwiseOr(c, ir.BitwiseXor(a, ir.BitwiseNot(b)));
     case 236:
         return ir.BitwiseOr(b, ir.BitwiseAnd(a, c));
     case 237:
-        return ir.BitwiseOr(b, ir.BitwiseNot(ir.BitwiseXor(a, c)));
+        return ir.BitwiseOr(b, ir.BitwiseXor(a, ir.BitwiseNot(c)));
     case 238:
         return ir.BitwiseOr(b, c);
     case 239:
-        return ir.BitwiseNot(ir.BitwiseAnd(a, ir.BitwiseNot(ir.BitwiseOr(b, c))));
+        return ir.BitwiseOr(ir.BitwiseOr(b, c), ir.BitwiseNot(a));
     case 240:
         return a;
     case 241:
         return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, c)));
     case 242:
-        return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseOr(b, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(a, ir.BitwiseAnd(c, ir.BitwiseNot(b)));
     case 243:
         return ir.BitwiseOr(a, ir.BitwiseNot(b));
     case 244:
@@ -542,15 +526,15 @@ IR::U32 ApplyLUT(IR::IREmitter& ir, const IR::U32& a, const IR::U32& b, const IR
     case 248:
         return ir.BitwiseOr(a, ir.BitwiseAnd(b, c));
     case 249:
-        return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseXor(b, c)));
+        return ir.BitwiseOr(a, ir.BitwiseXor(b, ir.BitwiseNot(c)));
     case 250:
         return ir.BitwiseOr(a, c);
     case 251:
-        return ir.BitwiseOr(a, ir.BitwiseNot(ir.BitwiseAnd(b, ir.BitwiseNot(c))));
+        return ir.BitwiseOr(ir.BitwiseOr(a, c), ir.BitwiseNot(b));
     case 252:
         return ir.BitwiseOr(a, b);
     case 253:
-        return ir.BitwiseOr(a, ir.BitwiseOr(b, ir.BitwiseNot(c)));
+        return ir.BitwiseOr(ir.BitwiseOr(a, b), ir.BitwiseNot(c));
     case 254:
         return ir.BitwiseOr(a, ir.BitwiseOr(b, c));
     case 255:

src/shader_recompiler/frontend/maxwell/translate/impl/logic_operation_three_input_lut3.py

@@ -3,32 +3,25 @@
 # terms of the Do What The Fuck You Want To Public License, Version 2,
 # as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.
 
-# Assume that the negation call is for free on the host GPU.
+from itertools import product
-# In fact, there are often input or output negation flags for logic operations
-support_neg = True
 
 # The primitive instructions
 OPS = {
-    'ir.BitwiseAnd({lhs}, {rhs})' : lambda a,b: a&b,
+    'ir.BitwiseAnd({}, {})' : (2, 1, lambda a,b: a&b),
-    'ir.BitwiseOr({lhs}, {rhs})' : lambda a,b: a|b,
+    'ir.BitwiseOr({}, {})' : (2, 1, lambda a,b: a|b),
-    'ir.BitwiseXor({lhs}, {rhs})' : lambda a,b: a^b,
+    'ir.BitwiseXor({}, {})' : (2, 1, lambda a,b: a^b),
+    'ir.BitwiseNot({})' : (1, 0.1, lambda a: (~a) & 255), # Only tiny cost, as this can often inlined in other instructions
 }
-if support_neg:
-    OPS.update({
-        'ir.BitwiseNot(ir.BitwiseAnd({lhs}, {rhs}))' : lambda a,b: 256 + ~(a&b),
-        'ir.BitwiseNot(ir.BitwiseOr({lhs}, {rhs}))' : lambda a,b: 256 + ~(a|b),
-        'ir.BitwiseNot(ir.BitwiseXor({lhs}, {rhs}))' : lambda a,b: 256 + ~(a^b),
-    })
 
 # Our database of combination of instructions
 optimized_calls = {}
 def register(imm, instruction, count, latency):
-    # Use the sum of instruction count and latency as metrik to evaluate which combination is best
+    # Use the sum of instruction count and latency as costs to evaluate which combination is best
-    metrik = count + latency
+    costs = count + latency + len(instruction) * 0.0001
 
     # Update if new or better
-    if imm not in optimized_calls or optimized_calls[imm][3] > metrik:
+    if imm not in optimized_calls or optimized_calls[imm][3] > costs:
-        optimized_calls[imm] = (instruction, count, latency, metrik)
+        optimized_calls[imm] = (instruction, count, latency, costs)
         return True
 
     return False
@@ -46,12 +39,6 @@ inputs = {
     tb : 'b',
     tc : 'c',
 }
-if support_neg:
-    inputs.update({
-        256 + ~ta : 'ir.BitwiseNot(a)',
-        256 + ~tb : 'ir.BitwiseNot(b)',
-        256 + ~tc : 'ir.BitwiseNot(c)',
-    })
 for imm, instruction in inputs.items():
     register(imm, instruction, 0, 0)
 
@@ -60,14 +47,19 @@ for imm, instruction in inputs.items():
 while True:
     registered = 0
     calls_copy = optimized_calls.copy()
-    for imm_a, (value_a, count_a, latency_a, metrik_a) in calls_copy.items():
+    for OP, (argc, cost, f) in OPS.items():
-        for imm_b, (value_b, count_b, latency_b, metrik_b) in calls_copy.items():
+        for args in product(calls_copy.items(), repeat=argc):
-            for OP, f in OPS.items():
+            # unpack(transponse) the arrays
-                registered += register(
+            imm = [arg[0] for arg in args]
-                    f(imm_a, imm_b), # Updated code
+            value = [arg[1][0] for arg in args]
-                    OP.format(lhs=value_a, rhs=value_b), # New instruction string
+            count = [arg[1][1] for arg in args]
-                    count_a+count_b+1, # Sum of instructions + 1
+            latency = [arg[1][2] for arg in args]
-                    max(latency_a, latency_b) + 1) # max latency + 1
+
+            registered += register(
+                f(*imm),
+                OP.format(*value),
+                sum(count) + cost,
+                max(latency) + cost)
     if registered == 0:
         # No update at all? So terminate
         break
@@ -76,4 +68,4 @@ while True:
 s = """    case {imm}:
         return {op};"""
 for imm in range(256):
-    print(s.format(imm=imm, op=optimized_calls[imm][0]))
+    print(s.format(imm=imm, op=optimized_calls[imm][0]))