Bad positions:
------------------------------------
1 3 5
00000001 = a
00000011 = b
00000101 = c
00000111 = xor
------------------------------------
1 4 6
00000001 = a
00000100 = b
00000110 = c
00000011 = xor
------------------------------------
1 7 9
00000001 = a
00000111 = b
00001001 = c
00001111 = xor
------------------------------------
1 8 10
00000001 = a
00001000 = b
00001010 = c
00000011 = xor
------------------------------------
1 11 13
00000001 = a
00001011 = b
00001101 = c
00000111 = xor
------------------------------------
1 12 14
00000001 = a
00001100 = b
00001110 = c
00000011 = xor
------------------------------------
1 15 17
00000001 = a
00001111 = b
00010001 = c
00011111 = xor
------------------------------------
1 16 18
00000001 = a
00010000 = b
00010010 = c
00000011 = xor
------------------------------------
1 19 21
00000001 = a
00010011 = b
00010101 = c
00000111 = xor
------------------------------------
1 20 22
00000001 = a
00010100 = b
00010110 = c
00000011 = xor
------------------------------------
1 23 25
00000001 = a
00010111 = b
00011001 = c
00001111 = xor
------------------------------------
1 24 26
00000001 = a
00011000 = b
00011010 = c
00000011 = xor
------------------------------------
1 27 29
00000001 = a
00011011 = b
00011101 = c
00000111 = xor
------------------------------------
1 28 30
00000001 = a
00011100 = b
00011110 = c
00000011 = xor
------------------------------------
1 31 33
00000001 = a
00011111 = b
00100001 = c
00111111 = xor
------------------------------------
1 32 34
00000001 = a
00100000 = b
00100010 = c
00000011 = xor
------------------------------------
1 35 37
00000001 = a
00100011 = b
00100101 = c
00000111 = xor
------------------------------------
1 36 38
00000001 = a
00100100 = b
00100110 = c
00000011 = xor
------------------------------------
1 39 41
00000001 = a
00100111 = b
00101001 = c
00001111 = xor
------------------------------------
1 40 42
00000001 = a
00101000 = b
00101010 = c
00000011 = xor
------------------------------------
1 43 45
00000001 = a
00101011 = b
00101101 = c
00000111 = xor
------------------------------------
1 44 46
00000001 = a
00101100 = b
00101110 = c
00000011 = xor
------------------------------------
1 47 49
00000001 = a
00101111 = b
00110001 = c
00011111 = xor
------------------------------------
1 48 50
00000001 = a
00110000 = b
00110010 = c
00000011 = xor
------------------------------------
1 51 53
00000001 = a
00110011 = b
00110101 = c
00000111 = xor
------------------------------------
1 52 54
00000001 = a
00110100 = b
00110110 = c
00000011 = xor
------------------------------------
1 55 57
00000001 = a
00110111 = b
00111001 = c
00001111 = xor
------------------------------------
1 56 58
00000001 = a
00111000 = b
00111010 = c
00000011 = xor
------------------------------------
1 59 61
00000001 = a
00111011 = b
00111101 = c
00000111 = xor
------------------------------------
1 60 62
00000001 = a
00111100 = b
00111110 = c
00000011 = xor
------------------------------------
1 63 65
00000001 = a
00111111 = b
01000001 = c
01111111 = xor
------------------------------------
1 64 66
00000001 = a
01000000 = b
01000010 = c
00000011 = xor
------------------------------------
1 67 69
00000001 = a
01000011 = b
01000101 = c
00000111 = xor
------------------------------------
1 68 70
00000001 = a
01000100 = b
01000110 = c
00000011 = xor
------------------------------------
1 71 73
00000001 = a
01000111 = b
01001001 = c
00001111 = xor
------------------------------------
1 72 74
00000001 = a
01001000 = b
01001010 = c
00000011 = xor
------------------------------------
1 75 77
00000001 = a
01001011 = b
01001101 = c
00000111 = xor
------------------------------------
1 76 78
00000001 = a
01001100 = b
01001110 = c
00000011 = xor
------------------------------------
1 79 81
00000001 = a
01001111 = b
01010001 = c
00011111 = xor
------------------------------------
1 80 82
00000001 = a
01010000 = b
01010010 = c
00000011 = xor
------------------------------------
1 83 85
00000001 = a
01010011 = b
01010101 = c
00000111 = xor
------------------------------------
1 84 86
00000001 = a
01010100 = b
01010110 = c
00000011 = xor
------------------------------------
1 87 89
00000001 = a
01010111 = b
01011001 = c
00001111 = xor
------------------------------------
1 88 90
00000001 = a
01011000 = b
01011010 = c
00000011 = xor
------------------------------------
1 91 93
00000001 = a
01011011 = b
01011101 = c
00000111 = xor
------------------------------------
1 92 94
00000001 = a
01011100 = b
01011110 = c
00000011 = xor
------------------------------------
1 95 97
00000001 = a
01011111 = b
01100001 = c
00111111 = xor
------------------------------------
1 96 98
00000001 = a
01100000 = b
01100010 = c
00000011 = xor
------------------------------------
2 3 6
00000010 = a
00000011 = b
00000110 = c
00000111 = xor
------------------------------------
2 4 5
00000010 = a
00000100 = b
00000101 = c
00000011 = xor
------------------------------------
2 7 10
00000010 = a
00000111 = b
00001010 = c
00001111 = xor
------------------------------------
2 8 9
00000010 = a
00001000 = b
00001001 = c
00000011 = xor
------------------------------------
2 11 14
00000010 = a
00001011 = b
00001110 = c
00000111 = xor
------------------------------------
2 12 13
00000010 = a
00001100 = b
00001101 = c
00000011 = xor
------------------------------------
2 15 18
00000010 = a
00001111 = b
00010010 = c
00011111 = xor
------------------------------------
2 16 17
00000010 = a
00010000 = b
00010001 = c
00000011 = xor
------------------------------------
2 19 22
00000010 = a
00010011 = b
00010110 = c
00000111 = xor
------------------------------------
2 20 21
00000010 = a
00010100 = b
00010101 = c
00000011 = xor
------------------------------------
2 23 26
00000010 = a
00010111 = b
00011010 = c
00001111 = xor
------------------------------------
2 24 25
00000010 = a
00011000 = b
00011001 = c
00000011 = xor
------------------------------------
2 27 30
00000010 = a
00011011 = b
00011110 = c
00000111 = xor
------------------------------------
2 28 29
00000010 = a
00011100 = b
00011101 = c
00000011 = xor
------------------------------------
2 31 34
00000010 = a
00011111 = b
00100010 = c
00111111 = xor
------------------------------------
2 32 33
00000010 = a
00100000 = b
00100001 = c
00000011 = xor
------------------------------------
2 35 38
00000010 = a
00100011 = b
00100110 = c
00000111 = xor
------------------------------------
2 36 37
00000010 = a
00100100 = b
00100101 = c
00000011 = xor
------------------------------------
2 39 42
00000010 = a
00100111 = b
00101010 = c
00001111 = xor
------------------------------------
2 40 41
00000010 = a
00101000 = b
00101001 = c
00000011 = xor
------------------------------------
2 43 46
00000010 = a
00101011 = b
00101110 = c
00000111 = xor
------------------------------------
2 44 45
00000010 = a
00101100 = b
00101101 = c
00000011 = xor
------------------------------------
2 47 50
00000010 = a
00101111 = b
00110010 = c
00011111 = xor
------------------------------------
2 48 49
00000010 = a
00110000 = b
00110001 = c
00000011 = xor
------------------------------------
2 51 54
00000010 = a
00110011 = b
00110110 = c
00000111 = xor
------------------------------------
2 52 53
00000010 = a
00110100 = b
00110101 = c
00000011 = xor
------------------------------------
2 55 58
00000010 = a
00110111 = b
00111010 = c
00001111 = xor
------------------------------------
2 56 57
00000010 = a
00111000 = b
00111001 = c
00000011 = xor
------------------------------------
2 59 62
00000010 = a
00111011 = b
00111110 = c
00000111 = xor
------------------------------------
2 60 61
00000010 = a
00111100 = b
00111101 = c
00000011 = xor
------------------------------------
2 63 66
00000010 = a
00111111 = b
01000010 = c
01111111 = xor
------------------------------------
2 64 65
00000010 = a
01000000 = b
01000001 = c
00000011 = xor
------------------------------------
2 67 70
00000010 = a
01000011 = b
01000110 = c
00000111 = xor
------------------------------------
2 68 69
00000010 = a
01000100 = b
01000101 = c
00000011 = xor
------------------------------------
2 71 74
00000010 = a
01000111 = b
01001010 = c
00001111 = xor
------------------------------------
2 72 73
00000010 = a
01001000 = b
01001001 = c
00000011 = xor
------------------------------------
2 75 78
00000010 = a
01001011 = b
01001110 = c
00000111 = xor
------------------------------------
2 76 77
00000010 = a
01001100 = b
01001101 = c
00000011 = xor
------------------------------------
2 79 82
00000010 = a
01001111 = b
01010010 = c
00011111 = xor
------------------------------------
2 80 81
00000010 = a
01010000 = b
01010001 = c
00000011 = xor
------------------------------------
2 83 86
00000010 = a
01010011 = b
01010110 = c
00000111 = xor
------------------------------------
2 84 85
00000010 = a
01010100 = b
01010101 = c
00000011 = xor
------------------------------------
2 87 90
00000010 = a
01010111 = b
01011010 = c
00001111 = xor
------------------------------------
2 88 89
00000010 = a
01011000 = b
01011001 = c
00000011 = xor
------------------------------------
2 91 94
00000010 = a
01011011 = b
01011110 = c
00000111 = xor
------------------------------------
2 92 93
00000010 = a
01011100 = b
01011101 = c
00000011 = xor
------------------------------------
2 95 98
00000010 = a
01011111 = b
01100010 = c
00111111 = xor
------------------------------------
2 96 97
00000010 = a
01100000 = b
01100001 = c
00000011 = xor
------------------------------------
3 7 11
00000011 = a
00000111 = b
00001011 = c
00001111 = xor
------------------------------------
3 8 12
00000011 = a
00001000 = b
00001100 = c
00000111 = xor
------------------------------------
3 9 13
00000011 = a
00001001 = b
00001101 = c
00000111 = xor
------------------------------------
3 10 14
00000011 = a
00001010 = b
00001110 = c
00000111 = xor
------------------------------------
3 15 19
00000011 = a
00001111 = b
00010011 = c
00011111 = xor
------------------------------------
3 16 20
00000011 = a
00010000 = b
00010100 = c
00000111 = xor
------------------------------------
3 17 21
00000011 = a
00010001 = b
00010101 = c
00000111 = xor
------------------------------------
3 18 22
00000011 = a
00010010 = b
00010110 = c
00000111 = xor
------------------------------------
3 23 27
00000011 = a
00010111 = b
00011011 = c
00001111 = xor
------------------------------------
3 24 28
00000011 = a
00011000 = b
00011100 = c
00000111 = xor
------------------------------------
3 25 29
00000011 = a
00011001 = b
00011101 = c
00000111 = xor
------------------------------------
3 26 30
00000011 = a
00011010 = b
00011110 = c
00000111 = xor
------------------------------------
3 31 35
00000011 = a
00011111 = b
00100011 = c
00111111 = xor
------------------------------------
3 32 36
00000011 = a
00100000 = b
00100100 = c
00000111 = xor
------------------------------------
3 33 37
00000011 = a
00100001 = b
00100101 = c
00000111 = xor
------------------------------------
3 34 38
00000011 = a
00100010 = b
00100110 = c
00000111 = xor
------------------------------------
3 39 43
00000011 = a
00100111 = b
00101011 = c
00001111 = xor
------------------------------------
3 40 44
00000011 = a
00101000 = b
00101100 = c
00000111 = xor
------------------------------------
3 41 45
00000011 = a
00101001 = b
00101101 = c
00000111 = xor
------------------------------------
3 42 46
00000011 = a
00101010 = b
00101110 = c
00000111 = xor
------------------------------------
3 47 51
00000011 = a
00101111 = b
00110011 = c
00011111 = xor
------------------------------------
3 48 52
00000011 = a
00110000 = b
00110100 = c
00000111 = xor
------------------------------------
3 49 53
00000011 = a
00110001 = b
00110101 = c
00000111 = xor
------------------------------------
3 50 54
00000011 = a
00110010 = b
00110110 = c
00000111 = xor
------------------------------------
3 55 59
00000011 = a
00110111 = b
00111011 = c
00001111 = xor
------------------------------------
3 56 60
00000011 = a
00111000 = b
00111100 = c
00000111 = xor
------------------------------------
3 57 61
00000011 = a
00111001 = b
00111101 = c
00000111 = xor
------------------------------------
3 58 62
00000011 = a
00111010 = b
00111110 = c
00000111 = xor
------------------------------------
3 63 67
00000011 = a
00111111 = b
01000011 = c
01111111 = xor
------------------------------------
3 64 68
00000011 = a
01000000 = b
01000100 = c
00000111 = xor
------------------------------------
3 65 69
00000011 = a
01000001 = b
01000101 = c
00000111 = xor
------------------------------------
3 66 70
00000011 = a
01000010 = b
01000110 = c
00000111 = xor
------------------------------------
3 71 75
00000011 = a
01000111 = b
01001011 = c
00001111 = xor
------------------------------------
3 72 76
00000011 = a
01001000 = b
01001100 = c
00000111 = xor
------------------------------------
3 73 77
00000011 = a
01001001 = b
01001101 = c
00000111 = xor
------------------------------------
3 74 78
00000011 = a
01001010 = b
01001110 = c
00000111 = xor
------------------------------------
3 79 83
00000011 = a
01001111 = b
01010011 = c
00011111 = xor
------------------------------------
3 80 84
00000011 = a
01010000 = b
01010100 = c
00000111 = xor
------------------------------------
3 81 85
00000011 = a
01010001 = b
01010101 = c
00000111 = xor
------------------------------------
3 82 86
00000011 = a
01010010 = b
01010110 = c
00000111 = xor
------------------------------------
3 87 91
00000011 = a
01010111 = b
01011011 = c
00001111 = xor
------------------------------------
3 88 92
00000011 = a
01011000 = b
01011100 = c
00000111 = xor
------------------------------------
3 89 93
00000011 = a
01011001 = b
01011101 = c
00000111 = xor
------------------------------------
3 90 94
00000011 = a
01011010 = b
01011110 = c
00000111 = xor
------------------------------------
3 95 99
00000011 = a
01011111 = b
01100011 = c
00111111 = xor
------------------------------------
3 96 100
00000011 = a
01100000 = b
01100100 = c
00000111 = xor
------------------------------------
4 7 12
00000100 = a
00000111 = b
00001100 = c
00001111 = xor
------------------------------------
4 8 11
00000100 = a
00001000 = b
00001011 = c
00000111 = xor
------------------------------------
4 9 14
00000100 = a
00001001 = b
00001110 = c
00000011 = xor
------------------------------------
4 10 13
00000100 = a
00001010 = b
00001101 = c
00000011 = xor
------------------------------------
4 15 20
00000100 = a
00001111 = b
00010100 = c
00011111 = xor
------------------------------------
4 16 19
00000100 = a
00010000 = b
00010011 = c
00000111 = xor
------------------------------------
4 17 22
00000100 = a
00010001 = b
00010110 = c
00000011 = xor
------------------------------------
4 18 21
00000100 = a
00010010 = b
00010101 = c
00000011 = xor
------------------------------------
4 23 28
00000100 = a
00010111 = b
00011100 = c
00001111 = xor
------------------------------------
4 24 27
00000100 = a
00011000 = b
00011011 = c
00000111 = xor
------------------------------------
4 25 30
00000100 = a
00011001 = b
00011110 = c
00000011 = xor
------------------------------------
4 26 29
00000100 = a
00011010 = b
00011101 = c
00000011 = xor
------------------------------------
4 31 36
00000100 = a
00011111 = b
00100100 = c
00111111 = xor
------------------------------------
4 32 35
00000100 = a
00100000 = b
00100011 = c
00000111 = xor
------------------------------------
4 33 38
00000100 = a
00100001 = b
00100110 = c
00000011 = xor
------------------------------------
4 34 37
00000100 = a
00100010 = b
00100101 = c
00000011 = xor
------------------------------------
4 39 44
00000100 = a
00100111 = b
00101100 = c
00001111 = xor
------------------------------------
4 40 43
00000100 = a
00101000 = b
00101011 = c
00000111 = xor
------------------------------------
4 41 46
00000100 = a
00101001 = b
00101110 = c
00000011 = xor
------------------------------------
4 42 45
00000100 = a
00101010 = b
00101101 = c
00000011 = xor
------------------------------------
4 47 52
00000100 = a
00101111 = b
00110100 = c
00011111 = xor
------------------------------------
4 48 51
00000100 = a
00110000 = b
00110011 = c
00000111 = xor
------------------------------------
4 49 54
00000100 = a
00110001 = b
00110110 = c
00000011 = xor
------------------------------------
4 50 53
00000100 = a
00110010 = b
00110101 = c
00000011 = xor
------------------------------------
4 55 60
00000100 = a
00110111 = b
00111100 = c
00001111 = xor
------------------------------------
4 56 59
00000100 = a
00111000 = b
00111011 = c
00000111 = xor
------------------------------------
4 57 62
00000100 = a
00111001 = b
00111110 = c
00000011 = xor
------------------------------------
4 58 61
00000100 = a
00111010 = b
00111101 = c
00000011 = xor
------------------------------------
4 63 68
00000100 = a
00111111 = b
01000100 = c
01111111 = xor
------------------------------------
4 64 67
00000100 = a
01000000 = b
01000011 = c
00000111 = xor
------------------------------------
4 65 70
00000100 = a
01000001 = b
01000110 = c
00000011 = xor
------------------------------------
4 66 69
00000100 = a
01000010 = b
01000101 = c
00000011 = xor
------------------------------------
4 71 76
00000100 = a
01000111 = b
01001100 = c
00001111 = xor
------------------------------------
4 72 75
00000100 = a
01001000 = b
01001011 = c
00000111 = xor
------------------------------------
4 73 78
00000100 = a
01001001 = b
01001110 = c
00000011 = xor
------------------------------------
4 74 77
00000100 = a
01001010 = b
01001101 = c
00000011 = xor
------------------------------------
4 79 84
00000100 = a
01001111 = b
01010100 = c
00011111 = xor
------------------------------------
4 80 83
00000100 = a
01010000 = b
01010011 = c
00000111 = xor
------------------------------------
4 81 86
00000100 = a
01010001 = b
01010110 = c
00000011 = xor
------------------------------------
4 82 85
00000100 = a
01010010 = b
01010101 = c
00000011 = xor
------------------------------------
4 87 92
00000100 = a
01010111 = b
01011100 = c
00001111 = xor
------------------------------------
4 88 91
00000100 = a
01011000 = b
01011011 = c
00000111 = xor
------------------------------------
4 89 94
00000100 = a
01011001 = b
01011110 = c
00000011 = xor
------------------------------------
4 90 93
00000100 = a
01011010 = b
01011101 = c
00000011 = xor
------------------------------------
4 95 100
00000100 = a
01011111 = b
01100100 = c
00111111 = xor
------------------------------------
4 96 99
00000100 = a
01100000 = b
01100011 = c
00000111 = xor
------------------------------------
5 7 13
00000101 = a
00000111 = b
00001101 = c
00001111 = xor
------------------------------------
5 8 14
00000101 = a
00001000 = b
00001110 = c
00000011 = xor
------------------------------------
5 9 11
00000101 = a
00001001 = b
00001011 = c
00000111 = xor
------------------------------------
5 10 12
00000101 = a
00001010 = b
00001100 = c
00000011 = xor
------------------------------------
5 15 21
00000101 = a
00001111 = b
00010101 = c
00011111 = xor
------------------------------------
5 16 22
00000101 = a
00010000 = b
00010110 = c
00000011 = xor
------------------------------------
5 17 19
00000101 = a
00010001 = b
00010011 = c
00000111 = xor
------------------------------------
5 18 20
00000101 = a
00010010 = b
00010100 = c
00000011 = xor
------------------------------------
5 23 29
00000101 = a
00010111 = b
00011101 = c
00001111 = xor
------------------------------------
5 24 30
00000101 = a
00011000 = b
00011110 = c
00000011 = xor
------------------------------------
5 25 27
00000101 = a
00011001 = b
00011011 = c
00000111 = xor
------------------------------------
5 26 28
00000101 = a
00011010 = b
00011100 = c
00000011 = xor
------------------------------------
5 31 37
00000101 = a
00011111 = b
00100101 = c
00111111 = xor
------------------------------------
5 32 38
00000101 = a
00100000 = b
00100110 = c
00000011 = xor
------------------------------------
5 33 35
00000101 = a
00100001 = b
00100011 = c
00000111 = xor
------------------------------------
5 34 36
00000101 = a
00100010 = b
00100100 = c
00000011 = xor
------------------------------------
5 39 45
00000101 = a
00100111 = b
00101101 = c
00001111 = xor
------------------------------------
5 40 46
00000101 = a
00101000 = b
00101110 = c
00000011 = xor
------------------------------------
5 41 43
00000101 = a
00101001 = b
00101011 = c
00000111 = xor
------------------------------------
5 42 44
00000101 = a
00101010 = b
00101100 = c
00000011 = xor
------------------------------------
5 47 53
00000101 = a
00101111 = b
00110101 = c
00011111 = xor
------------------------------------
5 48 54
00000101 = a
00110000 = b
00110110 = c
00000011 = xor
------------------------------------
5 49 51
00000101 = a
00110001 = b
00110011 = c
00000111 = xor
------------------------------------
5 50 52
00000101 = a
00110010 = b
00110100 = c
00000011 = xor
------------------------------------
5 55 61
00000101 = a
00110111 = b
00111101 = c
00001111 = xor
------------------------------------
5 56 62
00000101 = a
00111000 = b
00111110 = c
00000011 = xor
------------------------------------
5 57 59
00000101 = a
00111001 = b
00111011 = c
00000111 = xor
------------------------------------
5 58 60
00000101 = a
00111010 = b
00111100 = c
00000011 = xor
------------------------------------
5 63 69
00000101 = a
00111111 = b
01000101 = c
01111111 = xor
------------------------------------
5 64 70
00000101 = a
01000000 = b
01000110 = c
00000011 = xor
------------------------------------
5 65 67
00000101 = a
01000001 = b
01000011 = c
00000111 = xor
------------------------------------
5 66 68
00000101 = a
01000010 = b
01000100 = c
00000011 = xor
------------------------------------
5 71 77
00000101 = a
01000111 = b
01001101 = c
00001111 = xor
------------------------------------
5 72 78
00000101 = a
01001000 = b
01001110 = c
00000011 = xor
------------------------------------
5 73 75
00000101 = a
01001001 = b
01001011 = c
00000111 = xor
------------------------------------
5 74 76
00000101 = a
01001010 = b
01001100 = c
00000011 = xor
------------------------------------
5 79 85
00000101 = a
01001111 = b
01010101 = c
00011111 = xor
------------------------------------
5 80 86
00000101 = a
01010000 = b
01010110 = c
00000011 = xor
------------------------------------
5 81 83
00000101 = a
01010001 = b
01010011 = c
00000111 = xor
------------------------------------
5 82 84
00000101 = a
01010010 = b
01010100 = c
00000011 = xor
------------------------------------
5 87 93
00000101 = a
01010111 = b
01011101 = c
00001111 = xor
------------------------------------
5 88 94
00000101 = a
01011000 = b
01011110 = c
00000011 = xor
------------------------------------
5 89 91
00000101 = a
01011001 = b
01011011 = c
00000111 = xor
------------------------------------
5 90 92
00000101 = a
01011010 = b
01011100 = c
00000011 = xor
------------------------------------
5 97 99
00000101 = a
01100001 = b
01100011 = c
00000111 = xor
------------------------------------
5 98 100
00000101 = a
01100010 = b
01100100 = c
00000011 = xor
------------------------------------
6 7 14
00000110 = a
00000111 = b
00001110 = c
00001111 = xor
------------------------------------
6 8 13
00000110 = a
00001000 = b
00001101 = c
00000011 = xor
------------------------------------
6 9 12
00000110 = a
00001001 = b
00001100 = c
00000011 = xor
------------------------------------
6 10 11
00000110 = a
00001010 = b
00001011 = c
00000111 = xor
------------------------------------
6 15 22
00000110 = a
00001111 = b
00010110 = c
00011111 = xor
------------------------------------
6 16 21
00000110 = a
00010000 = b
00010101 = c
00000011 = xor
------------------------------------
6 17 20
00000110 = a
00010001 = b
00010100 = c
00000011 = xor
------------------------------------
6 18 19
00000110 = a
00010010 = b
00010011 = c
00000111 = xor
------------------------------------
6 23 30
00000110 = a
00010111 = b
00011110 = c
00001111 = xor
------------------------------------
6 24 29
00000110 = a
00011000 = b
00011101 = c
00000011 = xor
------------------------------------
6 25 28
00000110 = a
00011001 = b
00011100 = c
00000011 = xor
------------------------------------
6 26 27
00000110 = a
00011010 = b
00011011 = c
00000111 = xor
------------------------------------
6 31 38
00000110 = a
00011111 = b
00100110 = c
00111111 = xor
------------------------------------
6 32 37
00000110 = a
00100000 = b
00100101 = c
00000011 = xor
------------------------------------
6 33 36
00000110 = a
00100001 = b
00100100 = c
00000011 = xor
------------------------------------
6 34 35
00000110 = a
00100010 = b
00100011 = c
00000111 = xor
------------------------------------
6 39 46
00000110 = a
00100111 = b
00101110 = c
00001111 = xor
------------------------------------
6 40 45
00000110 = a
00101000 = b
00101101 = c
00000011 = xor
------------------------------------
6 41 44
00000110 = a
00101001 = b
00101100 = c
00000011 = xor
------------------------------------
6 42 43
00000110 = a
00101010 = b
00101011 = c
00000111 = xor
------------------------------------
6 47 54
00000110 = a
00101111 = b
00110110 = c
00011111 = xor
------------------------------------
6 48 53
00000110 = a
00110000 = b
00110101 = c
00000011 = xor
------------------------------------
6 49 52
00000110 = a
00110001 = b
00110100 = c
00000011 = xor
------------------------------------
6 50 51
00000110 = a
00110010 = b
00110011 = c
00000111 = xor
------------------------------------
6 55 62
00000110 = a
00110111 = b
00111110 = c
00001111 = xor
------------------------------------
6 56 61
00000110 = a
00111000 = b
00111101 = c
00000011 = xor
------------------------------------
6 57 60
00000110 = a
00111001 = b
00111100 = c
00000011 = xor
------------------------------------
6 58 59
00000110 = a
00111010 = b
00111011 = c
00000111 = xor
------------------------------------
6 63 70
00000110 = a
00111111 = b
01000110 = c
01111111 = xor
------------------------------------
6 64 69
00000110 = a
01000000 = b
01000101 = c
00000011 = xor
------------------------------------
6 65 68
00000110 = a
01000001 = b
01000100 = c
00000011 = xor
------------------------------------
6 66 67
00000110 = a
01000010 = b
01000011 = c
00000111 = xor
------------------------------------
6 71 78
00000110 = a
01000111 = b
01001110 = c
00001111 = xor
------------------------------------
6 72 77
00000110 = a
01001000 = b
01001101 = c
00000011 = xor
------------------------------------
6 73 76
00000110 = a
01001001 = b
01001100 = c
00000011 = xor
------------------------------------
6 74 75
00000110 = a
01001010 = b
01001011 = c
00000111 = xor
------------------------------------
6 79 86
00000110 = a
01001111 = b
01010110 = c
00011111 = xor
------------------------------------
6 80 85
00000110 = a
01010000 = b
01010101 = c
00000011 = xor
------------------------------------
6 81 84
00000110 = a
01010001 = b
01010100 = c
00000011 = xor
------------------------------------
6 82 83
00000110 = a
01010010 = b
01010011 = c
00000111 = xor
------------------------------------
6 87 94
00000110 = a
01010111 = b
01011110 = c
00001111 = xor
------------------------------------
6 88 93
00000110 = a
01011000 = b
01011101 = c
00000011 = xor
------------------------------------
6 89 92
00000110 = a
01011001 = b
01011100 = c
00000011 = xor
------------------------------------
6 90 91
00000110 = a
01011010 = b
01011011 = c
00000111 = xor
------------------------------------
6 97 100
00000110 = a
01100001 = b
01100100 = c
00000011 = xor
------------------------------------
6 98 99
00000110 = a
01100010 = b
01100011 = c
00000111 = xor
------------------------------------
7 15 23
00000111 = a
00001111 = b
00010111 = c
00011111 = xor
------------------------------------
7 16 24
00000111 = a
00010000 = b
00011000 = c
00001111 = xor
------------------------------------
7 17 25
00000111 = a
00010001 = b
00011001 = c
00001111 = xor
------------------------------------
7 18 26
00000111 = a
00010010 = b
00011010 = c
00001111 = xor
------------------------------------
7 19 27
00000111 = a
00010011 = b
00011011 = c
00001111 = xor
------------------------------------
7 20 28
00000111 = a
00010100 = b
00011100 = c
00001111 = xor
------------------------------------
7 21 29
00000111 = a
00010101 = b
00011101 = c
00001111 = xor
------------------------------------
7 22 30
00000111 = a
00010110 = b
00011110 = c
00001111 = xor
------------------------------------
7 31 39
00000111 = a
00011111 = b
00100111 = c
00111111 = xor
------------------------------------
7 32 40
00000111 = a
00100000 = b
00101000 = c
00001111 = xor
------------------------------------
7 33 41
00000111 = a
00100001 = b
00101001 = c
00001111 = xor
------------------------------------
7 34 42
00000111 = a
00100010 = b
00101010 = c
00001111 = xor
------------------------------------
7 35 43
00000111 = a
00100011 = b
00101011 = c
00001111 = xor
------------------------------------
7 36 44
00000111 = a
00100100 = b
00101100 = c
00001111 = xor
------------------------------------
7 37 45
00000111 = a
00100101 = b
00101101 = c
00001111 = xor
------------------------------------
7 38 46
00000111 = a
00100110 = b
00101110 = c
00001111 = xor
------------------------------------
7 47 55
00000111 = a
00101111 = b
00110111 = c
00011111 = xor
------------------------------------
7 48 56
00000111 = a
00110000 = b
00111000 = c
00001111 = xor
------------------------------------
7 49 57
00000111 = a
00110001 = b
00111001 = c
00001111 = xor
------------------------------------
7 50 58
00000111 = a
00110010 = b
00111010 = c
00001111 = xor
------------------------------------
7 51 59
00000111 = a
00110011 = b
00111011 = c
00001111 = xor
------------------------------------
7 52 60
00000111 = a
00110100 = b
00111100 = c
00001111 = xor
------------------------------------
7 53 61
00000111 = a
00110101 = b
00111101 = c
00001111 = xor
------------------------------------
7 54 62
00000111 = a
00110110 = b
00111110 = c
00001111 = xor
------------------------------------
7 63 71
00000111 = a
00111111 = b
01000111 = c
01111111 = xor
------------------------------------
7 64 72
00000111 = a
01000000 = b
01001000 = c
00001111 = xor
------------------------------------
7 65 73
00000111 = a
01000001 = b
01001001 = c
00001111 = xor
------------------------------------
7 66 74
00000111 = a
01000010 = b
01001010 = c
00001111 = xor
------------------------------------
7 67 75
00000111 = a
01000011 = b
01001011 = c
00001111 = xor
------------------------------------
7 68 76
00000111 = a
01000100 = b
01001100 = c
00001111 = xor
------------------------------------
7 69 77
00000111 = a
01000101 = b
01001101 = c
00001111 = xor
------------------------------------
7 70 78
00000111 = a
01000110 = b
01001110 = c
00001111 = xor
------------------------------------
7 79 87
00000111 = a
01001111 = b
01010111 = c
00011111 = xor
------------------------------------
7 80 88
00000111 = a
01010000 = b
01011000 = c
00001111 = xor
------------------------------------
7 81 89
00000111 = a
01010001 = b
01011001 = c
00001111 = xor
------------------------------------
7 82 90
00000111 = a
01010010 = b
01011010 = c
00001111 = xor
------------------------------------
7 83 91
00000111 = a
01010011 = b
01011011 = c
00001111 = xor
------------------------------------
7 84 92
00000111 = a
01010100 = b
01011100 = c
00001111 = xor
------------------------------------
7 85 93
00000111 = a
01010101 = b
01011101 = c
00001111 = xor
------------------------------------
7 86 94
00000111 = a
01010110 = b
01011110 = c
00001111 = xor
------------------------------------
8 15 24
00001000 = a
00001111 = b
00011000 = c
00011111 = xor
------------------------------------
8 16 23
00001000 = a
00010000 = b
00010111 = c
00001111 = xor
------------------------------------
8 17 26
00001000 = a
00010001 = b
00011010 = c
00000011 = xor
------------------------------------
8 18 25
00001000 = a
00010010 = b
00011001 = c
00000011 = xor
------------------------------------
8 19 28
00001000 = a
00010011 = b
00011100 = c
00000111 = xor
------------------------------------
8 20 27
00001000 = a
00010100 = b
00011011 = c
00000111 = xor
------------------------------------
8 21 30
00001000 = a
00010101 = b
00011110 = c
00000011 = xor
------------------------------------
8 22 29
00001000 = a
00010110 = b
00011101 = c
00000011 = xor
------------------------------------
8 31 40
00001000 = a
00011111 = b
00101000 = c
00111111 = xor
------------------------------------
8 32 39
00001000 = a
00100000 = b
00100111 = c
00001111 = xor
------------------------------------
8 33 42
00001000 = a
00100001 = b
00101010 = c
00000011 = xor
------------------------------------
8 34 41
00001000 = a
00100010 = b
00101001 = c
00000011 = xor
------------------------------------
8 35 44
00001000 = a
00100011 = b
00101100 = c
00000111 = xor
------------------------------------
8 36 43
00001000 = a
00100100 = b
00101011 = c
00000111 = xor
------------------------------------
8 37 46
00001000 = a
00100101 = b
00101110 = c
00000011 = xor
------------------------------------
8 38 45
00001000 = a
00100110 = b
00101101 = c
00000011 = xor
------------------------------------
8 47 56
00001000 = a
00101111 = b
00111000 = c
00011111 = xor
------------------------------------
8 48 55
00001000 = a
00110000 = b
00110111 = c
00001111 = xor
------------------------------------
8 49 58
00001000 = a
00110001 = b
00111010 = c
00000011 = xor
------------------------------------
8 50 57
00001000 = a
00110010 = b
00111001 = c
00000011 = xor
------------------------------------
8 51 60
00001000 = a
00110011 = b
00111100 = c
00000111 = xor
------------------------------------
8 52 59
00001000 = a
00110100 = b
00111011 = c
00000111 = xor
------------------------------------
8 53 62
00001000 = a
00110101 = b
00111110 = c
00000011 = xor
------------------------------------
8 54 61
00001000 = a
00110110 = b
00111101 = c
00000011 = xor
------------------------------------
8 63 72
00001000 = a
00111111 = b
01001000 = c
01111111 = xor
------------------------------------
8 64 71
00001000 = a
01000000 = b
01000111 = c
00001111 = xor
------------------------------------
8 65 74
00001000 = a
01000001 = b
01001010 = c
00000011 = xor
------------------------------------
8 66 73
00001000 = a
01000010 = b
01001001 = c
00000011 = xor
------------------------------------
8 67 76
00001000 = a
01000011 = b
01001100 = c
00000111 = xor
------------------------------------
8 68 75
00001000 = a
01000100 = b
01001011 = c
00000111 = xor
------------------------------------
8 69 78
00001000 = a
01000101 = b
01001110 = c
00000011 = xor
------------------------------------
8 70 77
00001000 = a
01000110 = b
01001101 = c
00000011 = xor
------------------------------------
8 79 88
00001000 = a
01001111 = b
01011000 = c
00011111 = xor
------------------------------------
8 80 87
00001000 = a
01010000 = b
01010111 = c
00001111 = xor
------------------------------------
8 81 90
00001000 = a
01010001 = b
01011010 = c
00000011 = xor
------------------------------------
8 82 89
00001000 = a
01010010 = b
01011001 = c
00000011 = xor
------------------------------------
8 83 92
00001000 = a
01010011 = b
01011100 = c
00000111 = xor
------------------------------------
8 84 91
00001000 = a
01010100 = b
01011011 = c
00000111 = xor
------------------------------------
8 85 94
00001000 = a
01010101 = b
01011110 = c
00000011 = xor
------------------------------------
8 86 93
00001000 = a
01010110 = b
01011101 = c
00000011 = xor
------------------------------------
9 15 25
00001001 = a
00001111 = b
00011001 = c
00011111 = xor
------------------------------------
9 16 26
00001001 = a
00010000 = b
00011010 = c
00000011 = xor
------------------------------------
9 17 23
00001001 = a
00010001 = b
00010111 = c
00001111 = xor
------------------------------------
9 18 24
00001001 = a
00010010 = b
00011000 = c
00000011 = xor
------------------------------------
9 19 29
00001001 = a
00010011 = b
00011101 = c
00000111 = xor
------------------------------------
9 20 30
00001001 = a
00010100 = b
00011110 = c
00000011 = xor
------------------------------------
9 21 27
00001001 = a
00010101 = b
00011011 = c
00000111 = xor
------------------------------------
9 22 28
00001001 = a
00010110 = b
00011100 = c
00000011 = xor
------------------------------------
9 31 41
00001001 = a
00011111 = b
00101001 = c
00111111 = xor
------------------------------------
9 32 42
00001001 = a
00100000 = b
00101010 = c
00000011 = xor
------------------------------------
9 33 39
00001001 = a
00100001 = b
00100111 = c
00001111 = xor
------------------------------------
9 34 40
00001001 = a
00100010 = b
00101000 = c
00000011 = xor
------------------------------------
9 35 45
00001001 = a
00100011 = b
00101101 = c
00000111 = xor
------------------------------------
9 36 46
00001001 = a
00100100 = b
00101110 = c
00000011 = xor
------------------------------------
9 37 43
00001001 = a
00100101 = b
00101011 = c
00000111 = xor
------------------------------------
9 38 44
00001001 = a
00100110 = b
00101100 = c
00000011 = xor
------------------------------------
9 47 57
00001001 = a
00101111 = b
00111001 = c
00011111 = xor
------------------------------------
9 48 58
00001001 = a
00110000 = b
00111010 = c
00000011 = xor
------------------------------------
9 49 55
00001001 = a
00110001 = b
00110111 = c
00001111 = xor
------------------------------------
9 50 56
00001001 = a
00110010 = b
00111000 = c
00000011 = xor
------------------------------------
9 51 61
00001001 = a
00110011 = b
00111101 = c
00000111 = xor
------------------------------------
9 52 62
00001001 = a
00110100 = b
00111110 = c
00000011 = xor
------------------------------------
9 53 59
00001001 = a
00110101 = b
00111011 = c
00000111 = xor
------------------------------------
9 54 60
00001001 = a
00110110 = b
00111100 = c
00000011 = xor
------------------------------------
9 63 73
00001001 = a
00111111 = b
01001001 = c
01111111 = xor
------------------------------------
9 64 74
00001001 = a
01000000 = b
01001010 = c
00000011 = xor
------------------------------------
9 65 71
00001001 = a
01000001 = b
01000111 = c
00001111 = xor
------------------------------------
9 66 72
00001001 = a
01000010 = b
01001000 = c
00000011 = xor
------------------------------------
9 67 77
00001001 = a
01000011 = b
01001101 = c
00000111 = xor
------------------------------------
9 68 78
00001001 = a
01000100 = b
01001110 = c
00000011 = xor
------------------------------------
9 69 75
00001001 = a
01000101 = b
01001011 = c
00000111 = xor
------------------------------------
9 70 76
00001001 = a
01000110 = b
01001100 = c
00000011 = xor
------------------------------------
9 79 89
00001001 = a
01001111 = b
01011001 = c
00011111 = xor
------------------------------------
9 80 90
00001001 = a
01010000 = b
01011010 = c
00000011 = xor
------------------------------------
9 81 87
00001001 = a
01010001 = b
01010111 = c
00001111 = xor
------------------------------------
9 82 88
00001001 = a
01010010 = b
01011000 = c
00000011 = xor
------------------------------------
9 83 93
00001001 = a
01010011 = b
01011101 = c
00000111 = xor
------------------------------------
9 84 94
00001001 = a
01010100 = b
01011110 = c
00000011 = xor
------------------------------------
9 85 91
00001001 = a
01010101 = b
01011011 = c
00000111 = xor
------------------------------------
9 86 92
00001001 = a
01010110 = b
01011100 = c
00000011 = xor
------------------------------------
10 15 26
00001010 = a
00001111 = b
00011010 = c
00011111 = xor
------------------------------------
10 16 25
00001010 = a
00010000 = b
00011001 = c
00000011 = xor
------------------------------------
10 17 24
00001010 = a
00010001 = b
00011000 = c
00000011 = xor
------------------------------------
10 18 23
00001010 = a
00010010 = b
00010111 = c
00001111 = xor
------------------------------------
10 19 30
00001010 = a
00010011 = b
00011110 = c
00000111 = xor
------------------------------------
10 20 29
00001010 = a
00010100 = b
00011101 = c
00000011 = xor
------------------------------------
10 21 28
00001010 = a
00010101 = b
00011100 = c
00000011 = xor
------------------------------------
10 22 27
00001010 = a
00010110 = b
00011011 = c
00000111 = xor
------------------------------------
10 31 42
00001010 = a
00011111 = b
00101010 = c
00111111 = xor
------------------------------------
10 32 41
00001010 = a
00100000 = b
00101001 = c
00000011 = xor
------------------------------------
10 33 40
00001010 = a
00100001 = b
00101000 = c
00000011 = xor
------------------------------------
10 34 39
00001010 = a
00100010 = b
00100111 = c
00001111 = xor
------------------------------------
10 35 46
00001010 = a
00100011 = b
00101110 = c
00000111 = xor
------------------------------------
10 36 45
00001010 = a
00100100 = b
00101101 = c
00000011 = xor
------------------------------------
10 37 44
00001010 = a
00100101 = b
00101100 = c
00000011 = xor
------------------------------------
10 38 43
00001010 = a
00100110 = b
00101011 = c
00000111 = xor
------------------------------------
10 47 58
00001010 = a
00101111 = b
00111010 = c
00011111 = xor
------------------------------------
10 48 57
00001010 = a
00110000 = b
00111001 = c
00000011 = xor
------------------------------------
10 49 56
00001010 = a
00110001 = b
00111000 = c
00000011 = xor
------------------------------------
10 50 55
00001010 = a
00110010 = b
00110111 = c
00001111 = xor
------------------------------------
10 51 62
00001010 = a
00110011 = b
00111110 = c
00000111 = xor
------------------------------------
10 52 61
00001010 = a
00110100 = b
00111101 = c
00000011 = xor
------------------------------------
10 53 60
00001010 = a
00110101 = b
00111100 = c
00000011 = xor
------------------------------------
10 54 59
00001010 = a
00110110 = b
00111011 = c
00000111 = xor
------------------------------------
10 63 74
00001010 = a
00111111 = b
01001010 = c
01111111 = xor
------------------------------------
10 64 73
00001010 = a
01000000 = b
01001001 = c
00000011 = xor
------------------------------------
10 65 72
00001010 = a
01000001 = b
01001000 = c
00000011 = xor
------------------------------------
10 66 71
00001010 = a
01000010 = b
01000111 = c
00001111 = xor
------------------------------------
10 67 78
00001010 = a
01000011 = b
01001110 = c
00000111 = xor
------------------------------------
10 68 77
00001010 = a
01000100 = b
01001101 = c
00000011 = xor
------------------------------------
10 69 76
00001010 = a
01000101 = b
01001100 = c
00000011 = xor
------------------------------------
10 70 75
00001010 = a
01000110 = b
01001011 = c
00000111 = xor
------------------------------------
10 79 90
00001010 = a
01001111 = b
01011010 = c
00011111 = xor
------------------------------------
10 80 89
00001010 = a
01010000 = b
01011001 = c
00000011 = xor
------------------------------------
10 81 88
00001010 = a
01010001 = b
01011000 = c
00000011 = xor
------------------------------------
10 82 87
00001010 = a
01010010 = b
01010111 = c
00001111 = xor
------------------------------------
10 83 94
00001010 = a
01010011 = b
01011110 = c
00000111 = xor
------------------------------------
10 84 93
00001010 = a
01010100 = b
01011101 = c
00000011 = xor
------------------------------------
10 85 92
00001010 = a
01010101 = b
01011100 = c
00000011 = xor
------------------------------------
10 86 91
00001010 = a
01010110 = b
01011011 = c
00000111 = xor
------------------------------------
11 15 27
00001011 = a
00001111 = b
00011011 = c
00011111 = xor
------------------------------------
11 16 28
00001011 = a
00010000 = b
00011100 = c
00000111 = xor
------------------------------------
11 17 29
00001011 = a
00010001 = b
00011101 = c
00000111 = xor
------------------------------------
11 18 30
00001011 = a
00010010 = b
00011110 = c
00000111 = xor
------------------------------------
11 19 23
00001011 = a
00010011 = b
00010111 = c
00001111 = xor
------------------------------------
11 20 24
00001011 = a
00010100 = b
00011000 = c
00000111 = xor
------------------------------------
11 21 25
00001011 = a
00010101 = b
00011001 = c
00000111 = xor
------------------------------------
11 22 26
00001011 = a
00010110 = b
00011010 = c
00000111 = xor
------------------------------------
11 31 43
00001011 = a
00011111 = b
00101011 = c
00111111 = xor
------------------------------------
11 32 44
00001011 = a
00100000 = b
00101100 = c
00000111 = xor
------------------------------------
11 33 45
00001011 = a
00100001 = b
00101101 = c
00000111 = xor
------------------------------------
11 34 46
00001011 = a
00100010 = b
00101110 = c
00000111 = xor
------------------------------------
11 35 39
00001011 = a
00100011 = b
00100111 = c
00001111 = xor
------------------------------------
11 36 40
00001011 = a
00100100 = b
00101000 = c
00000111 = xor
------------------------------------
11 37 41
00001011 = a
00100101 = b
00101001 = c
00000111 = xor
------------------------------------
11 38 42
00001011 = a
00100110 = b
00101010 = c
00000111 = xor
------------------------------------
11 47 59
00001011 = a
00101111 = b
00111011 = c
00011111 = xor
------------------------------------
11 48 60
00001011 = a
00110000 = b
00111100 = c
00000111 = xor
------------------------------------
11 49 61
00001011 = a
00110001 = b
00111101 = c
00000111 = xor
------------------------------------
11 50 62
00001011 = a
00110010 = b
00111110 = c
00000111 = xor
------------------------------------
11 51 55
00001011 = a
00110011 = b
00110111 = c
00001111 = xor
------------------------------------
11 52 56
00001011 = a
00110100 = b
00111000 = c
00000111 = xor
------------------------------------
11 53 57
00001011 = a
00110101 = b
00111001 = c
00000111 = xor
------------------------------------
11 54 58
00001011 = a
00110110 = b
00111010 = c
00000111 = xor
------------------------------------
11 63 75
00001011 = a
00111111 = b
01001011 = c
01111111 = xor
------------------------------------
11 64 76
00001011 = a
01000000 = b
01001100 = c
00000111 = xor
------------------------------------
11 65 77
00001011 = a
01000001 = b
01001101 = c
00000111 = xor
------------------------------------
11 66 78
00001011 = a
01000010 = b
01001110 = c
00000111 = xor
------------------------------------
11 67 71
00001011 = a
01000011 = b
01000111 = c
00001111 = xor
------------------------------------
11 68 72
00001011 = a
01000100 = b
01001000 = c
00000111 = xor
------------------------------------
11 69 73
00001011 = a
01000101 = b
01001001 = c
00000111 = xor
------------------------------------
11 70 74
00001011 = a
01000110 = b
01001010 = c
00000111 = xor
------------------------------------
11 79 91
00001011 = a
01001111 = b
01011011 = c
00011111 = xor
------------------------------------
11 80 92
00001011 = a
01010000 = b
01011100 = c
00000111 = xor
------------------------------------
11 81 93
00001011 = a
01010001 = b
01011101 = c
00000111 = xor
------------------------------------
11 82 94
00001011 = a
01010010 = b
01011110 = c
00000111 = xor
------------------------------------
11 83 87
00001011 = a
01010011 = b
01010111 = c
00001111 = xor
------------------------------------
11 84 88
00001011 = a
01010100 = b
01011000 = c
00000111 = xor
------------------------------------
11 85 89
00001011 = a
01010101 = b
01011001 = c
00000111 = xor
------------------------------------
11 86 90
00001011 = a
01010110 = b
01011010 = c
00000111 = xor
------------------------------------
12 15 28
00001100 = a
00001111 = b
00011100 = c
00011111 = xor
------------------------------------
12 16 27
00001100 = a
00010000 = b
00011011 = c
00000111 = xor
------------------------------------
12 17 30
00001100 = a
00010001 = b
00011110 = c
00000011 = xor
------------------------------------
12 18 29
00001100 = a
00010010 = b
00011101 = c
00000011 = xor
------------------------------------
12 19 24
00001100 = a
00010011 = b
00011000 = c
00000111 = xor
------------------------------------
12 20 23
00001100 = a
00010100 = b
00010111 = c
00001111 = xor
------------------------------------
12 21 26
00001100 = a
00010101 = b
00011010 = c
00000011 = xor
------------------------------------
12 22 25
00001100 = a
00010110 = b
00011001 = c
00000011 = xor
------------------------------------
12 31 44
00001100 = a
00011111 = b
00101100 = c
00111111 = xor
------------------------------------
12 32 43
00001100 = a
00100000 = b
00101011 = c
00000111 = xor
------------------------------------
12 33 46
00001100 = a
00100001 = b
00101110 = c
00000011 = xor
------------------------------------
12 34 45
00001100 = a
00100010 = b
00101101 = c
00000011 = xor
------------------------------------
12 35 40
00001100 = a
00100011 = b
00101000 = c
00000111 = xor
------------------------------------
12 36 39
00001100 = a
00100100 = b
00100111 = c
00001111 = xor
------------------------------------
12 37 42
00001100 = a
00100101 = b
00101010 = c
00000011 = xor
------------------------------------
12 38 41
00001100 = a
00100110 = b
00101001 = c
00000011 = xor
------------------------------------
12 47 60
00001100 = a
00101111 = b
00111100 = c
00011111 = xor
------------------------------------
12 48 59
00001100 = a
00110000 = b
00111011 = c
00000111 = xor
------------------------------------
12 49 62
00001100 = a
00110001 = b
00111110 = c
00000011 = xor
------------------------------------
12 50 61
00001100 = a
00110010 = b
00111101 = c
00000011 = xor
------------------------------------
12 51 56
00001100 = a
00110011 = b
00111000 = c
00000111 = xor
------------------------------------
12 52 55
00001100 = a
00110100 = b
00110111 = c
00001111 = xor
------------------------------------
12 53 58
00001100 = a
00110101 = b
00111010 = c
00000011 = xor
------------------------------------
12 54 57
00001100 = a
00110110 = b
00111001 = c
00000011 = xor
------------------------------------
12 63 76
00001100 = a
00111111 = b
01001100 = c
01111111 = xor
------------------------------------
12 64 75
00001100 = a
01000000 = b
01001011 = c
00000111 = xor
------------------------------------
12 65 78
00001100 = a
01000001 = b
01001110 = c
00000011 = xor
------------------------------------
12 66 77
00001100 = a
01000010 = b
01001101 = c
00000011 = xor
------------------------------------
12 67 72
00001100 = a
01000011 = b
01001000 = c
00000111 = xor
------------------------------------
12 68 71
00001100 = a
01000100 = b
01000111 = c
00001111 = xor
------------------------------------
12 69 74
00001100 = a
01000101 = b
01001010 = c
00000011 = xor
------------------------------------
12 70 73
00001100 = a
01000110 = b
01001001 = c
00000011 = xor
------------------------------------
12 79 92
00001100 = a
01001111 = b
01011100 = c
00011111 = xor
------------------------------------
12 80 91
00001100 = a
01010000 = b
01011011 = c
00000111 = xor
------------------------------------
12 81 94
00001100 = a
01010001 = b
01011110 = c
00000011 = xor
------------------------------------
12 82 93
00001100 = a
01010010 = b
01011101 = c
00000011 = xor
------------------------------------
12 83 88
00001100 = a
01010011 = b
01011000 = c
00000111 = xor
------------------------------------
12 84 87
00001100 = a
01010100 = b
01010111 = c
00001111 = xor
------------------------------------
12 85 90
00001100 = a
01010101 = b
01011010 = c
00000011 = xor
------------------------------------
12 86 89
00001100 = a
01010110 = b
01011001 = c
00000011 = xor
------------------------------------
13 15 29
00001101 = a
00001111 = b
00011101 = c
00011111 = xor
------------------------------------
13 16 30
00001101 = a
00010000 = b
00011110 = c
00000011 = xor
------------------------------------
13 17 27
00001101 = a
00010001 = b
00011011 = c
00000111 = xor
------------------------------------
13 18 28
00001101 = a
00010010 = b
00011100 = c
00000011 = xor
------------------------------------
13 19 25
00001101 = a
00010011 = b
00011001 = c
00000111 = xor
------------------------------------
13 20 26
00001101 = a
00010100 = b
00011010 = c
00000011 = xor
------------------------------------
13 21 23
00001101 = a
00010101 = b
00010111 = c
00001111 = xor
------------------------------------
13 22 24
00001101 = a
00010110 = b
00011000 = c
00000011 = xor
------------------------------------
13 31 45
00001101 = a
00011111 = b
00101101 = c
00111111 = xor
------------------------------------
13 32 46
00001101 = a
00100000 = b
00101110 = c
00000011 = xor
------------------------------------
13 33 43
00001101 = a
00100001 = b
00101011 = c
00000111 = xor
------------------------------------
13 34 44
00001101 = a
00100010 = b
00101100 = c
00000011 = xor
------------------------------------
13 35 41
00001101 = a
00100011 = b
00101001 = c
00000111 = xor
------------------------------------
13 36 42
00001101 = a
00100100 = b
00101010 = c
00000011 = xor
------------------------------------
13 37 39
00001101 = a
00100101 = b
00100111 = c
00001111 = xor
------------------------------------
13 38 40
00001101 = a
00100110 = b
00101000 = c
00000011 = xor
------------------------------------
13 47 61
00001101 = a
00101111 = b
00111101 = c
00011111 = xor
------------------------------------
13 48 62
00001101 = a
00110000 = b
00111110 = c
00000011 = xor
------------------------------------
13 49 59
00001101 = a
00110001 = b
00111011 = c
00000111 = xor
------------------------------------
13 50 60
00001101 = a
00110010 = b
00111100 = c
00000011 = xor
------------------------------------
13 51 57
00001101 = a
00110011 = b
00111001 = c
00000111 = xor
------------------------------------
13 52 58
00001101 = a
00110100 = b
00111010 = c
00000011 = xor
------------------------------------
13 53 55
00001101 = a
00110101 = b
00110111 = c
00001111 = xor
------------------------------------
13 54 56
00001101 = a
00110110 = b
00111000 = c
00000011 = xor
------------------------------------
13 63 77
00001101 = a
00111111 = b
01001101 = c
01111111 = xor
------------------------------------
13 64 78
00001101 = a
01000000 = b
01001110 = c
00000011 = xor
------------------------------------
13 65 75
00001101 = a
01000001 = b
01001011 = c
00000111 = xor
------------------------------------
13 66 76
00001101 = a
01000010 = b
01001100 = c
00000011 = xor
------------------------------------
13 67 73
00001101 = a
01000011 = b
01001001 = c
00000111 = xor
------------------------------------
13 68 74
00001101 = a
01000100 = b
01001010 = c
00000011 = xor
------------------------------------
13 69 71
00001101 = a
01000101 = b
01000111 = c
00001111 = xor
------------------------------------
13 70 72
00001101 = a
01000110 = b
01001000 = c
00000011 = xor
------------------------------------
13 79 93
00001101 = a
01001111 = b
01011101 = c
00011111 = xor
------------------------------------
13 80 94
00001101 = a
01010000 = b
01011110 = c
00000011 = xor
------------------------------------
13 81 91
00001101 = a
01010001 = b
01011011 = c
00000111 = xor
------------------------------------
13 82 92
00001101 = a
01010010 = b
01011100 = c
00000011 = xor
------------------------------------
13 83 89
00001101 = a
01010011 = b
01011001 = c
00000111 = xor
------------------------------------
13 84 90
00001101 = a
01010100 = b
01011010 = c
00000011 = xor
------------------------------------
13 85 87
00001101 = a
01010101 = b
01010111 = c
00001111 = xor
------------------------------------
13 86 88
00001101 = a
01010110 = b
01011000 = c
00000011 = xor
------------------------------------
14 15 30
00001110 = a
00001111 = b
00011110 = c
00011111 = xor
------------------------------------
14 16 29
00001110 = a
00010000 = b
00011101 = c
00000011 = xor
------------------------------------
14 17 28
00001110 = a
00010001 = b
00011100 = c
00000011 = xor
------------------------------------
14 18 27
00001110 = a
00010010 = b
00011011 = c
00000111 = xor
------------------------------------
14 19 26
00001110 = a
00010011 = b
00011010 = c
00000111 = xor
------------------------------------
14 20 25
00001110 = a
00010100 = b
00011001 = c
00000011 = xor
------------------------------------
14 21 24
00001110 = a
00010101 = b
00011000 = c
00000011 = xor
------------------------------------
14 22 23
00001110 = a
00010110 = b
00010111 = c
00001111 = xor
------------------------------------
14 31 46
00001110 = a
00011111 = b
00101110 = c
00111111 = xor
------------------------------------
14 32 45
00001110 = a
00100000 = b
00101101 = c
00000011 = xor
------------------------------------
14 33 44
00001110 = a
00100001 = b
00101100 = c
00000011 = xor
------------------------------------
14 34 43
00001110 = a
00100010 = b
00101011 = c
00000111 = xor
------------------------------------
14 35 42
00001110 = a
00100011 = b
00101010 = c
00000111 = xor
------------------------------------
14 36 41
00001110 = a
00100100 = b
00101001 = c
00000011 = xor
------------------------------------
14 37 40
00001110 = a
00100101 = b
00101000 = c
00000011 = xor
------------------------------------
14 38 39
00001110 = a
00100110 = b
00100111 = c
00001111 = xor
------------------------------------
14 47 62
00001110 = a
00101111 = b
00111110 = c
00011111 = xor
------------------------------------
14 48 61
00001110 = a
00110000 = b
00111101 = c
00000011 = xor
------------------------------------
14 49 60
00001110 = a
00110001 = b
00111100 = c
00000011 = xor
------------------------------------
14 50 59
00001110 = a
00110010 = b
00111011 = c
00000111 = xor
------------------------------------
14 51 58
00001110 = a
00110011 = b
00111010 = c
00000111 = xor
------------------------------------
14 52 57
00001110 = a
00110100 = b
00111001 = c
00000011 = xor
------------------------------------
14 53 56
00001110 = a
00110101 = b
00111000 = c
00000011 = xor
------------------------------------
14 54 55
00001110 = a
00110110 = b
00110111 = c
00001111 = xor
------------------------------------
14 63 78
00001110 = a
00111111 = b
01001110 = c
01111111 = xor
------------------------------------
14 64 77
00001110 = a
01000000 = b
01001101 = c
00000011 = xor
------------------------------------
14 65 76
00001110 = a
01000001 = b
01001100 = c
00000011 = xor
------------------------------------
14 66 75
00001110 = a
01000010 = b
01001011 = c
00000111 = xor
------------------------------------
14 67 74
00001110 = a
01000011 = b
01001010 = c
00000111 = xor
------------------------------------
14 68 73
00001110 = a
01000100 = b
01001001 = c
00000011 = xor
------------------------------------
14 69 72
00001110 = a
01000101 = b
01001000 = c
00000011 = xor
------------------------------------
14 70 71
00001110 = a
01000110 = b
01000111 = c
00001111 = xor
------------------------------------
14 79 94
00001110 = a
01001111 = b
01011110 = c
00011111 = xor
------------------------------------
14 80 93
00001110 = a
01010000 = b
01011101 = c
00000011 = xor
------------------------------------
14 81 92
00001110 = a
01010001 = b
01011100 = c
00000011 = xor
------------------------------------
14 82 91
00001110 = a
01010010 = b
01011011 = c
00000111 = xor
------------------------------------
14 83 90
00001110 = a
01010011 = b
01011010 = c
00000111 = xor
------------------------------------
14 84 89
00001110 = a
01010100 = b
01011001 = c
00000011 = xor
------------------------------------
14 85 88
00001110 = a
01010101 = b
01011000 = c
00000011 = xor
------------------------------------
14 86 87
00001110 = a
01010110 = b
01010111 = c
00001111 = xor
------------------------------------
15 31 47
00001111 = a
00011111 = b
00101111 = c
00111111 = xor
------------------------------------
15 32 48
00001111 = a
00100000 = b
00110000 = c
00011111 = xor
------------------------------------
15 33 49
00001111 = a
00100001 = b
00110001 = c
00011111 = xor
------------------------------------
15 34 50
00001111 = a
00100010 = b
00110010 = c
00011111 = xor
------------------------------------
15 35 51
00001111 = a
00100011 = b
00110011 = c
00011111 = xor
------------------------------------
15 36 52
00001111 = a
00100100 = b
00110100 = c
00011111 = xor
------------------------------------
15 37 53
00001111 = a
00100101 = b
00110101 = c
00011111 = xor
------------------------------------
15 38 54
00001111 = a
00100110 = b
00110110 = c
00011111 = xor
------------------------------------
15 39 55
00001111 = a
00100111 = b
00110111 = c
00011111 = xor
------------------------------------
15 40 56
00001111 = a
00101000 = b
00111000 = c
00011111 = xor
------------------------------------
15 41 57
00001111 = a
00101001 = b
00111001 = c
00011111 = xor
------------------------------------
15 42 58
00001111 = a
00101010 = b
00111010 = c
00011111 = xor
------------------------------------
15 43 59
00001111 = a
00101011 = b
00111011 = c
00011111 = xor
------------------------------------
15 44 60
00001111 = a
00101100 = b
00111100 = c
00011111 = xor
------------------------------------
15 45 61
00001111 = a
00101101 = b
00111101 = c
00011111 = xor
------------------------------------
15 46 62
00001111 = a
00101110 = b
00111110 = c
00011111 = xor
------------------------------------
15 63 79
00001111 = a
00111111 = b
01001111 = c
01111111 = xor
------------------------------------
15 64 80
00001111 = a
01000000 = b
01010000 = c
00011111 = xor
------------------------------------
15 65 81
00001111 = a
01000001 = b
01010001 = c
00011111 = xor
------------------------------------
15 66 82
00001111 = a
01000010 = b
01010010 = c
00011111 = xor
------------------------------------
15 67 83
00001111 = a
01000011 = b
01010011 = c
00011111 = xor
------------------------------------
15 68 84
00001111 = a
01000100 = b
01010100 = c
00011111 = xor
------------------------------------
15 69 85
00001111 = a
01000101 = b
01010101 = c
00011111 = xor
------------------------------------
15 70 86
00001111 = a
01000110 = b
01010110 = c
00011111 = xor
------------------------------------
15 71 87
00001111 = a
01000111 = b
01010111 = c
00011111 = xor
------------------------------------
15 72 88
00001111 = a
01001000 = b
01011000 = c
00011111 = xor
------------------------------------
15 73 89
00001111 = a
01001001 = b
01011001 = c
00011111 = xor
------------------------------------
15 74 90
00001111 = a
01001010 = b
01011010 = c
00011111 = xor
------------------------------------
15 75 91
00001111 = a
01001011 = b
01011011 = c
00011111 = xor
------------------------------------
15 76 92
00001111 = a
01001100 = b
01011100 = c
00011111 = xor
------------------------------------
15 77 93
00001111 = a
01001101 = b
01011101 = c
00011111 = xor
------------------------------------
15 78 94
00001111 = a
01001110 = b
01011110 = c
00011111 = xor
------------------------------------
16 31 48
00010000 = a
00011111 = b
00110000 = c
00111111 = xor
------------------------------------
16 32 47
00010000 = a
00100000 = b
00101111 = c
00011111 = xor
------------------------------------
16 33 50
00010000 = a
00100001 = b
00110010 = c
00000011 = xor
------------------------------------
16 34 49
00010000 = a
00100010 = b
00110001 = c
00000011 = xor
------------------------------------
16 35 52
00010000 = a
00100011 = b
00110100 = c
00000111 = xor
------------------------------------
16 36 51
00010000 = a
00100100 = b
00110011 = c
00000111 = xor
------------------------------------
16 37 54
00010000 = a
00100101 = b
00110110 = c
00000011 = xor
------------------------------------
16 38 53
00010000 = a
00100110 = b
00110101 = c
00000011 = xor
------------------------------------
16 39 56
00010000 = a
00100111 = b
00111000 = c
00001111 = xor
------------------------------------
16 40 55
00010000 = a
00101000 = b
00110111 = c
00001111 = xor
------------------------------------
16 41 58
00010000 = a
00101001 = b
00111010 = c
00000011 = xor
------------------------------------
16 42 57
00010000 = a
00101010 = b
00111001 = c
00000011 = xor
------------------------------------
16 43 60
00010000 = a
00101011 = b
00111100 = c
00000111 = xor
------------------------------------
16 44 59
00010000 = a
00101100 = b
00111011 = c
00000111 = xor
------------------------------------
16 45 62
00010000 = a
00101101 = b
00111110 = c
00000011 = xor
------------------------------------
16 46 61
00010000 = a
00101110 = b
00111101 = c
00000011 = xor
------------------------------------
16 63 80
00010000 = a
00111111 = b
01010000 = c
01111111 = xor
------------------------------------
16 64 79
00010000 = a
01000000 = b
01001111 = c
00011111 = xor
------------------------------------
16 65 82
00010000 = a
01000001 = b
01010010 = c
00000011 = xor
------------------------------------
16 66 81
00010000 = a
01000010 = b
01010001 = c
00000011 = xor
------------------------------------
16 67 84
00010000 = a
01000011 = b
01010100 = c
00000111 = xor
------------------------------------
16 68 83
00010000 = a
01000100 = b
01010011 = c
00000111 = xor
------------------------------------
16 69 86
00010000 = a
01000101 = b
01010110 = c
00000011 = xor
------------------------------------
16 70 85
00010000 = a
01000110 = b
01010101 = c
00000011 = xor
------------------------------------
16 71 88
00010000 = a
01000111 = b
01011000 = c
00001111 = xor
------------------------------------
16 72 87
00010000 = a
01001000 = b
01010111 = c
00001111 = xor
------------------------------------
16 73 90
00010000 = a
01001001 = b
01011010 = c
00000011 = xor
------------------------------------
16 74 89
00010000 = a
01001010 = b
01011001 = c
00000011 = xor
------------------------------------
16 75 92
00010000 = a
01001011 = b
01011100 = c
00000111 = xor
------------------------------------
16 76 91
00010000 = a
01001100 = b
01011011 = c
00000111 = xor
------------------------------------
16 77 94
00010000 = a
01001101 = b
01011110 = c
00000011 = xor
------------------------------------
16 78 93
00010000 = a
01001110 = b
01011101 = c
00000011 = xor
------------------------------------
17 31 49
00010001 = a
00011111 = b
00110001 = c
00111111 = xor
------------------------------------
17 32 50
00010001 = a
00100000 = b
00110010 = c
00000011 = xor
------------------------------------
17 33 47
00010001 = a
00100001 = b
00101111 = c
00011111 = xor
------------------------------------
17 34 48
00010001 = a
00100010 = b
00110000 = c
00000011 = xor
------------------------------------
17 35 53
00010001 = a
00100011 = b
00110101 = c
00000111 = xor
------------------------------------
17 36 54
00010001 = a
00100100 = b
00110110 = c
00000011 = xor
------------------------------------
17 37 51
00010001 = a
00100101 = b
00110011 = c
00000111 = xor
------------------------------------
17 38 52
00010001 = a
00100110 = b
00110100 = c
00000011 = xor
------------------------------------
17 39 57
00010001 = a
00100111 = b
00111001 = c
00001111 = xor
------------------------------------
17 40 58
00010001 = a
00101000 = b
00111010 = c
00000011 = xor
------------------------------------
17 41 55
00010001 = a
00101001 = b
00110111 = c
00001111 = xor
------------------------------------
17 42 56
00010001 = a
00101010 = b
00111000 = c
00000011 = xor
------------------------------------
17 43 61
00010001 = a
00101011 = b
00111101 = c
00000111 = xor
------------------------------------
17 44 62
00010001 = a
00101100 = b
00111110 = c
00000011 = xor
------------------------------------
17 45 59
00010001 = a
00101101 = b
00111011 = c
00000111 = xor
------------------------------------
17 46 60
00010001 = a
00101110 = b
00111100 = c
00000011 = xor
------------------------------------
17 63 81
00010001 = a
00111111 = b
01010001 = c
01111111 = xor
------------------------------------
17 64 82
00010001 = a
01000000 = b
01010010 = c
00000011 = xor
------------------------------------
17 65 79
00010001 = a
01000001 = b
01001111 = c
00011111 = xor
------------------------------------
17 66 80
00010001 = a
01000010 = b
01010000 = c
00000011 = xor
------------------------------------
17 67 85
00010001 = a
01000011 = b
01010101 = c
00000111 = xor
------------------------------------
17 68 86
00010001 = a
01000100 = b
01010110 = c
00000011 = xor
------------------------------------
17 69 83
00010001 = a
01000101 = b
01010011 = c
00000111 = xor
------------------------------------
17 70 84
00010001 = a
01000110 = b
01010100 = c
00000011 = xor
------------------------------------
17 71 89
00010001 = a
01000111 = b
01011001 = c
00001111 = xor
------------------------------------
17 72 90
00010001 = a
01001000 = b
01011010 = c
00000011 = xor
------------------------------------
17 73 87
00010001 = a
01001001 = b
01010111 = c
00001111 = xor
------------------------------------
17 74 88
00010001 = a
01001010 = b
01011000 = c
00000011 = xor
------------------------------------
17 75 93
00010001 = a
01001011 = b
01011101 = c
00000111 = xor
------------------------------------
17 76 94
00010001 = a
01001100 = b
01011110 = c
00000011 = xor
------------------------------------
17 77 91
00010001 = a
01001101 = b
01011011 = c
00000111 = xor
------------------------------------
17 78 92
00010001 = a
01001110 = b
01011100 = c
00000011 = xor
------------------------------------
18 31 50
00010010 = a
00011111 = b
00110010 = c
00111111 = xor
------------------------------------
18 32 49
00010010 = a
00100000 = b
00110001 = c
00000011 = xor
------------------------------------
18 33 48
00010010 = a
00100001 = b
00110000 = c
00000011 = xor
------------------------------------
18 34 47
00010010 = a
00100010 = b
00101111 = c
00011111 = xor
------------------------------------
18 35 54
00010010 = a
00100011 = b
00110110 = c
00000111 = xor
------------------------------------
18 36 53
00010010 = a
00100100 = b
00110101 = c
00000011 = xor
------------------------------------
18 37 52
00010010 = a
00100101 = b
00110100 = c
00000011 = xor
------------------------------------
18 38 51
00010010 = a
00100110 = b
00110011 = c
00000111 = xor
------------------------------------
18 39 58
00010010 = a
00100111 = b
00111010 = c
00001111 = xor
------------------------------------
18 40 57
00010010 = a
00101000 = b
00111001 = c
00000011 = xor
------------------------------------
18 41 56
00010010 = a
00101001 = b
00111000 = c
00000011 = xor
------------------------------------
18 42 55
00010010 = a
00101010 = b
00110111 = c
00001111 = xor
------------------------------------
18 43 62
00010010 = a
00101011 = b
00111110 = c
00000111 = xor
------------------------------------
18 44 61
00010010 = a
00101100 = b
00111101 = c
00000011 = xor
------------------------------------
18 45 60
00010010 = a
00101101 = b
00111100 = c
00000011 = xor
------------------------------------
18 46 59
00010010 = a
00101110 = b
00111011 = c
00000111 = xor
------------------------------------
18 63 82
00010010 = a
00111111 = b
01010010 = c
01111111 = xor
------------------------------------
18 64 81
00010010 = a
01000000 = b
01010001 = c
00000011 = xor
------------------------------------
18 65 80
00010010 = a
01000001 = b
01010000 = c
00000011 = xor
------------------------------------
18 66 79
00010010 = a
01000010 = b
01001111 = c
00011111 = xor
------------------------------------
18 67 86
00010010 = a
01000011 = b
01010110 = c
00000111 = xor
------------------------------------
18 68 85
00010010 = a
01000100 = b
01010101 = c
00000011 = xor
------------------------------------
18 69 84
00010010 = a
01000101 = b
01010100 = c
00000011 = xor
------------------------------------
18 70 83
00010010 = a
01000110 = b
01010011 = c
00000111 = xor
------------------------------------
18 71 90
00010010 = a
01000111 = b
01011010 = c
00001111 = xor
------------------------------------
18 72 89
00010010 = a
01001000 = b
01011001 = c
00000011 = xor
------------------------------------
18 73 88
00010010 = a
01001001 = b
01011000 = c
00000011 = xor
------------------------------------
18 74 87
00010010 = a
01001010 = b
01010111 = c
00001111 = xor
------------------------------------
18 75 94
00010010 = a
01001011 = b
01011110 = c
00000111 = xor
------------------------------------
18 76 93
00010010 = a
01001100 = b
01011101 = c
00000011 = xor
------------------------------------
18 77 92
00010010 = a
01001101 = b
01011100 = c
00000011 = xor
------------------------------------
18 78 91
00010010 = a
01001110 = b
01011011 = c
00000111 = xor
------------------------------------
19 31 51
00010011 = a
00011111 = b
00110011 = c
00111111 = xor
------------------------------------
19 32 52
00010011 = a
00100000 = b
00110100 = c
00000111 = xor
------------------------------------
19 33 53
00010011 = a
00100001 = b
00110101 = c
00000111 = xor
------------------------------------
19 34 54
00010011 = a
00100010 = b
00110110 = c
00000111 = xor
------------------------------------
19 35 47
00010011 = a
00100011 = b
00101111 = c
00011111 = xor
------------------------------------
19 36 48
00010011 = a
00100100 = b
00110000 = c
00000111 = xor
------------------------------------
19 37 49
00010011 = a
00100101 = b
00110001 = c
00000111 = xor
------------------------------------
19 38 50
00010011 = a
00100110 = b
00110010 = c
00000111 = xor
------------------------------------
19 39 59
00010011 = a
00100111 = b
00111011 = c
00001111 = xor
------------------------------------
19 40 60
00010011 = a
00101000 = b
00111100 = c
00000111 = xor
------------------------------------
19 41 61
00010011 = a
00101001 = b
00111101 = c
00000111 = xor
------------------------------------
19 42 62
00010011 = a
00101010 = b
00111110 = c
00000111 = xor
------------------------------------
19 43 55
00010011 = a
00101011 = b
00110111 = c
00001111 = xor
------------------------------------
19 44 56
00010011 = a
00101100 = b
00111000 = c
00000111 = xor
------------------------------------
19 45 57
00010011 = a
00101101 = b
00111001 = c
00000111 = xor
------------------------------------
19 46 58
00010011 = a
00101110 = b
00111010 = c
00000111 = xor
------------------------------------
19 63 83
00010011 = a
00111111 = b
01010011 = c
01111111 = xor
------------------------------------
19 64 84
00010011 = a
01000000 = b
01010100 = c
00000111 = xor
------------------------------------
19 65 85
00010011 = a
01000001 = b
01010101 = c
00000111 = xor
------------------------------------
19 66 86
00010011 = a
01000010 = b
01010110 = c
00000111 = xor
------------------------------------
19 67 79
00010011 = a
01000011 = b
01001111 = c
00011111 = xor
------------------------------------
19 68 80
00010011 = a
01000100 = b
01010000 = c
00000111 = xor
------------------------------------
19 69 81
00010011 = a
01000101 = b
01010001 = c
00000111 = xor
------------------------------------
19 70 82
00010011 = a
01000110 = b
01010010 = c
00000111 = xor
------------------------------------
19 71 91
00010011 = a
01000111 = b
01011011 = c
00001111 = xor
------------------------------------
19 72 92
00010011 = a
01001000 = b
01011100 = c
00000111 = xor
------------------------------------
19 73 93
00010011 = a
01001001 = b
01011101 = c
00000111 = xor
------------------------------------
19 74 94
00010011 = a
01001010 = b
01011110 = c
00000111 = xor
------------------------------------
19 75 87
00010011 = a
01001011 = b
01010111 = c
00001111 = xor
------------------------------------
19 76 88
00010011 = a
01001100 = b
01011000 = c
00000111 = xor
------------------------------------
19 77 89
00010011 = a
01001101 = b
01011001 = c
00000111 = xor
------------------------------------
19 78 90
00010011 = a
01001110 = b
01011010 = c
00000111 = xor
------------------------------------
20 31 52
00010100 = a
00011111 = b
00110100 = c
00111111 = xor
------------------------------------
20 32 51
00010100 = a
00100000 = b
00110011 = c
00000111 = xor
------------------------------------
20 33 54
00010100 = a
00100001 = b
00110110 = c
00000011 = xor
------------------------------------
20 34 53
00010100 = a
00100010 = b
00110101 = c
00000011 = xor
------------------------------------
20 35 48
00010100 = a
00100011 = b
00110000 = c
00000111 = xor
------------------------------------
20 36 47
00010100 = a
00100100 = b
00101111 = c
00011111 = xor
------------------------------------
20 37 50
00010100 = a
00100101 = b
00110010 = c
00000011 = xor
------------------------------------
20 38 49
00010100 = a
00100110 = b
00110001 = c
00000011 = xor
------------------------------------
20 39 60
00010100 = a
00100111 = b
00111100 = c
00001111 = xor
------------------------------------
20 40 59
00010100 = a
00101000 = b
00111011 = c
00000111 = xor
------------------------------------
20 41 62
00010100 = a
00101001 = b
00111110 = c
00000011 = xor
------------------------------------
20 42 61
00010100 = a
00101010 = b
00111101 = c
00000011 = xor
------------------------------------
20 43 56
00010100 = a
00101011 = b
00111000 = c
00000111 = xor
------------------------------------
20 44 55
00010100 = a
00101100 = b
00110111 = c
00001111 = xor
------------------------------------
20 45 58
00010100 = a
00101101 = b
00111010 = c
00000011 = xor
------------------------------------
20 46 57
00010100 = a
00101110 = b
00111001 = c
00000011 = xor
------------------------------------
20 63 84
00010100 = a
00111111 = b
01010100 = c
01111111 = xor
------------------------------------
20 64 83
00010100 = a
01000000 = b
01010011 = c
00000111 = xor
------------------------------------
20 65 86
00010100 = a
01000001 = b
01010110 = c
00000011 = xor
------------------------------------
20 66 85
00010100 = a
01000010 = b
01010101 = c
00000011 = xor
------------------------------------
20 67 80
00010100 = a
01000011 = b
01010000 = c
00000111 = xor
------------------------------------
20 68 79
00010100 = a
01000100 = b
01001111 = c
00011111 = xor
------------------------------------
20 69 82
00010100 = a
01000101 = b
01010010 = c
00000011 = xor
------------------------------------
20 70 81
00010100 = a
01000110 = b
01010001 = c
00000011 = xor
------------------------------------
20 71 92
00010100 = a
01000111 = b
01011100 = c
00001111 = xor
------------------------------------
20 72 91
00010100 = a
01001000 = b
01011011 = c
00000111 = xor
------------------------------------
20 73 94
00010100 = a
01001001 = b
01011110 = c
00000011 = xor
------------------------------------
20 74 93
00010100 = a
01001010 = b
01011101 = c
00000011 = xor
------------------------------------
20 75 88
00010100 = a
01001011 = b
01011000 = c
00000111 = xor
------------------------------------
20 76 87
00010100 = a
01001100 = b
01010111 = c
00001111 = xor
------------------------------------
20 77 90
00010100 = a
01001101 = b
01011010 = c
00000011 = xor
------------------------------------
20 78 89
00010100 = a
01001110 = b
01011001 = c
00000011 = xor
------------------------------------
21 31 53
00010101 = a
00011111 = b
00110101 = c
00111111 = xor
------------------------------------
21 32 54
00010101 = a
00100000 = b
00110110 = c
00000011 = xor
------------------------------------
21 33 51
00010101 = a
00100001 = b
00110011 = c
00000111 = xor
------------------------------------
21 34 52
00010101 = a
00100010 = b
00110100 = c
00000011 = xor
------------------------------------
21 35 49
00010101 = a
00100011 = b
00110001 = c
00000111 = xor
------------------------------------
21 36 50
00010101 = a
00100100 = b
00110010 = c
00000011 = xor
------------------------------------
21 37 47
00010101 = a
00100101 = b
00101111 = c
00011111 = xor
------------------------------------
21 38 48
00010101 = a
00100110 = b
00110000 = c
00000011 = xor
------------------------------------
21 39 61
00010101 = a
00100111 = b
00111101 = c
00001111 = xor
------------------------------------
21 40 62
00010101 = a
00101000 = b
00111110 = c
00000011 = xor
------------------------------------
21 41 59
00010101 = a
00101001 = b
00111011 = c
00000111 = xor
------------------------------------
21 42 60
00010101 = a
00101010 = b
00111100 = c
00000011 = xor
------------------------------------
21 43 57
00010101 = a
00101011 = b
00111001 = c
00000111 = xor
------------------------------------
21 44 58
00010101 = a
00101100 = b
00111010 = c
00000011 = xor
------------------------------------
21 45 55
00010101 = a
00101101 = b
00110111 = c
00001111 = xor
------------------------------------
21 46 56
00010101 = a
00101110 = b
00111000 = c
00000011 = xor
------------------------------------
21 63 85
00010101 = a
00111111 = b
01010101 = c
01111111 = xor
------------------------------------
21 64 86
00010101 = a
01000000 = b
01010110 = c
00000011 = xor
------------------------------------
21 65 83
00010101 = a
01000001 = b
01010011 = c
00000111 = xor
------------------------------------
21 66 84
00010101 = a
01000010 = b
01010100 = c
00000011 = xor
------------------------------------
21 67 81
00010101 = a
01000011 = b
01010001 = c
00000111 = xor
------------------------------------
21 68 82
00010101 = a
01000100 = b
01010010 = c
00000011 = xor
------------------------------------
21 69 79
00010101 = a
01000101 = b
01001111 = c
00011111 = xor
------------------------------------
21 70 80
00010101 = a
01000110 = b
01010000 = c
00000011 = xor
------------------------------------
21 71 93
00010101 = a
01000111 = b
01011101 = c
00001111 = xor
------------------------------------
21 72 94
00010101 = a
01001000 = b
01011110 = c
00000011 = xor
------------------------------------
21 73 91
00010101 = a
01001001 = b
01011011 = c
00000111 = xor
------------------------------------
21 74 92
00010101 = a
01001010 = b
01011100 = c
00000011 = xor
------------------------------------
21 75 89
00010101 = a
01001011 = b
01011001 = c
00000111 = xor
------------------------------------
21 76 90
00010101 = a
01001100 = b
01011010 = c
00000011 = xor
------------------------------------
21 77 87
00010101 = a
01001101 = b
01010111 = c
00001111 = xor
------------------------------------
21 78 88
00010101 = a
01001110 = b
01011000 = c
00000011 = xor
------------------------------------
22 31 54
00010110 = a
00011111 = b
00110110 = c
00111111 = xor
------------------------------------
22 32 53
00010110 = a
00100000 = b
00110101 = c
00000011 = xor
------------------------------------
22 33 52
00010110 = a
00100001 = b
00110100 = c
00000011 = xor
------------------------------------
22 34 51
00010110 = a
00100010 = b
00110011 = c
00000111 = xor
------------------------------------
22 35 50
00010110 = a
00100011 = b
00110010 = c
00000111 = xor
------------------------------------
22 36 49
00010110 = a
00100100 = b
00110001 = c
00000011 = xor
------------------------------------
22 37 48
00010110 = a
00100101 = b
00110000 = c
00000011 = xor
------------------------------------
22 38 47
00010110 = a
00100110 = b
00101111 = c
00011111 = xor
------------------------------------
22 39 62
00010110 = a
00100111 = b
00111110 = c
00001111 = xor
------------------------------------
22 40 61
00010110 = a
00101000 = b
00111101 = c
00000011 = xor
------------------------------------
22 41 60
00010110 = a
00101001 = b
00111100 = c
00000011 = xor
------------------------------------
22 42 59
00010110 = a
00101010 = b
00111011 = c
00000111 = xor
------------------------------------
22 43 58
00010110 = a
00101011 = b
00111010 = c
00000111 = xor
------------------------------------
22 44 57
00010110 = a
00101100 = b
00111001 = c
00000011 = xor
------------------------------------
22 45 56
00010110 = a
00101101 = b
00111000 = c
00000011 = xor
------------------------------------
22 46 55
00010110 = a
00101110 = b
00110111 = c
00001111 = xor
------------------------------------
22 63 86
00010110 = a
00111111 = b
01010110 = c
01111111 = xor
------------------------------------
22 64 85
00010110 = a
01000000 = b
01010101 = c
00000011 = xor
------------------------------------
22 65 84
00010110 = a
01000001 = b
01010100 = c
00000011 = xor
------------------------------------
22 66 83
00010110 = a
01000010 = b
01010011 = c
00000111 = xor
------------------------------------
22 67 82
00010110 = a
01000011 = b
01010010 = c
00000111 = xor
------------------------------------
22 68 81
00010110 = a
01000100 = b
01010001 = c
00000011 = xor
------------------------------------
22 69 80
00010110 = a
01000101 = b
01010000 = c
00000011 = xor
------------------------------------
22 70 79
00010110 = a
01000110 = b
01001111 = c
00011111 = xor
------------------------------------
22 71 94
00010110 = a
01000111 = b
01011110 = c
00001111 = xor
------------------------------------
22 72 93
00010110 = a
01001000 = b
01011101 = c
00000011 = xor
------------------------------------
22 73 92
00010110 = a
01001001 = b
01011100 = c
00000011 = xor
------------------------------------
22 74 91
00010110 = a
01001010 = b
01011011 = c
00000111 = xor
------------------------------------
22 75 90
00010110 = a
01001011 = b
01011010 = c
00000111 = xor
------------------------------------
22 76 89
00010110 = a
01001100 = b
01011001 = c
00000011 = xor
------------------------------------
22 77 88
00010110 = a
01001101 = b
01011000 = c
00000011 = xor
------------------------------------
22 78 87
00010110 = a
01001110 = b
01010111 = c
00001111 = xor
------------------------------------
23 31 55
00010111 = a
00011111 = b
00110111 = c
00111111 = xor
------------------------------------
23 32 56
00010111 = a
00100000 = b
00111000 = c
00001111 = xor
------------------------------------
23 33 57
00010111 = a
00100001 = b
00111001 = c
00001111 = xor
------------------------------------
23 34 58
00010111 = a
00100010 = b
00111010 = c
00001111 = xor
------------------------------------
23 35 59
00010111 = a
00100011 = b
00111011 = c
00001111 = xor
------------------------------------
23 36 60
00010111 = a
00100100 = b
00111100 = c
00001111 = xor
------------------------------------
23 37 61
00010111 = a
00100101 = b
00111101 = c
00001111 = xor
------------------------------------
23 38 62
00010111 = a
00100110 = b
00111110 = c
00001111 = xor
------------------------------------
23 39 47
00010111 = a
00100111 = b
00101111 = c
00011111 = xor
------------------------------------
23 40 48
00010111 = a
00101000 = b
00110000 = c
00001111 = xor
------------------------------------
23 41 49
00010111 = a
00101001 = b
00110001 = c
00001111 = xor
------------------------------------
23 42 50
00010111 = a
00101010 = b
00110010 = c
00001111 = xor
------------------------------------
23 43 51
00010111 = a
00101011 = b
00110011 = c
00001111 = xor
------------------------------------
23 44 52
00010111 = a
00101100 = b
00110100 = c
00001111 = xor
------------------------------------
23 45 53
00010111 = a
00101101 = b
00110101 = c
00001111 = xor
------------------------------------
23 46 54
00010111 = a
00101110 = b
00110110 = c
00001111 = xor
------------------------------------
23 63 87
00010111 = a
00111111 = b
01010111 = c
01111111 = xor
------------------------------------
23 64 88
00010111 = a
01000000 = b
01011000 = c
00001111 = xor
------------------------------------
23 65 89
00010111 = a
01000001 = b
01011001 = c
00001111 = xor
------------------------------------
23 66 90
00010111 = a
01000010 = b
01011010 = c
00001111 = xor
------------------------------------
23 67 91
00010111 = a
01000011 = b
01011011 = c
00001111 = xor
------------------------------------
23 68 92
00010111 = a
01000100 = b
01011100 = c
00001111 = xor
------------------------------------
23 69 93
00010111 = a
01000101 = b
01011101 = c
00001111 = xor
------------------------------------
23 70 94
00010111 = a
01000110 = b
01011110 = c
00001111 = xor
------------------------------------
23 71 79
00010111 = a
01000111 = b
01001111 = c
00011111 = xor
------------------------------------
23 72 80
00010111 = a
01001000 = b
01010000 = c
00001111 = xor
------------------------------------
23 73 81
00010111 = a
01001001 = b
01010001 = c
00001111 = xor
------------------------------------
23 74 82
00010111 = a
01001010 = b
01010010 = c
00001111 = xor
------------------------------------
23 75 83
00010111 = a
01001011 = b
01010011 = c
00001111 = xor
------------------------------------
23 76 84
00010111 = a
01001100 = b
01010100 = c
00001111 = xor
------------------------------------
23 77 85
00010111 = a
01001101 = b
01010101 = c
00001111 = xor
------------------------------------
23 78 86
00010111 = a
01001110 = b
01010110 = c
00001111 = xor
------------------------------------
24 31 56
00011000 = a
00011111 = b
00111000 = c
00111111 = xor
------------------------------------
24 32 55
00011000 = a
00100000 = b
00110111 = c
00001111 = xor
------------------------------------
24 33 58
00011000 = a
00100001 = b
00111010 = c
00000011 = xor
------------------------------------
24 34 57
00011000 = a
00100010 = b
00111001 = c
00000011 = xor
------------------------------------
24 35 60
00011000 = a
00100011 = b
00111100 = c
00000111 = xor
------------------------------------
24 36 59
00011000 = a
00100100 = b
00111011 = c
00000111 = xor
------------------------------------
24 37 62
00011000 = a
00100101 = b
00111110 = c
00000011 = xor
------------------------------------
24 38 61
00011000 = a
00100110 = b
00111101 = c
00000011 = xor
------------------------------------
24 39 48
00011000 = a
00100111 = b
00110000 = c
00001111 = xor
------------------------------------
24 40 47
00011000 = a
00101000 = b
00101111 = c
00011111 = xor
------------------------------------
24 41 50
00011000 = a
00101001 = b
00110010 = c
00000011 = xor
------------------------------------
24 42 49
00011000 = a
00101010 = b
00110001 = c
00000011 = xor
------------------------------------
24 43 52
00011000 = a
00101011 = b
00110100 = c
00000111 = xor
------------------------------------
24 44 51
00011000 = a
00101100 = b
00110011 = c
00000111 = xor
------------------------------------
24 45 54
00011000 = a
00101101 = b
00110110 = c
00000011 = xor
------------------------------------
24 46 53
00011000 = a
00101110 = b
00110101 = c
00000011 = xor
------------------------------------
24 63 88
00011000 = a
00111111 = b
01011000 = c
01111111 = xor
------------------------------------
24 64 87
00011000 = a
01000000 = b
01010111 = c
00001111 = xor
------------------------------------
24 65 90
00011000 = a
01000001 = b
01011010 = c
00000011 = xor
------------------------------------
24 66 89
00011000 = a
01000010 = b
01011001 = c
00000011 = xor
------------------------------------
24 67 92
00011000 = a
01000011 = b
01011100 = c
00000111 = xor
------------------------------------
24 68 91
00011000 = a
01000100 = b
01011011 = c
00000111 = xor
------------------------------------
24 69 94
00011000 = a
01000101 = b
01011110 = c
00000011 = xor
------------------------------------
24 70 93
00011000 = a
01000110 = b
01011101 = c
00000011 = xor
------------------------------------
24 71 80
00011000 = a
01000111 = b
01010000 = c
00001111 = xor
------------------------------------
24 72 79
00011000 = a
01001000 = b
01001111 = c
00011111 = xor
------------------------------------
24 73 82
00011000 = a
01001001 = b
01010010 = c
00000011 = xor
------------------------------------
24 74 81
00011000 = a
01001010 = b
01010001 = c
00000011 = xor
------------------------------------
24 75 84
00011000 = a
01001011 = b
01010100 = c
00000111 = xor
------------------------------------
24 76 83
00011000 = a
01001100 = b
01010011 = c
00000111 = xor
------------------------------------
24 77 86
00011000 = a
01001101 = b
01010110 = c
00000011 = xor
------------------------------------
24 78 85
00011000 = a
01001110 = b
01010101 = c
00000011 = xor
------------------------------------
25 31 57
00011001 = a
00011111 = b
00111001 = c
00111111 = xor
------------------------------------
25 32 58
00011001 = a
00100000 = b
00111010 = c
00000011 = xor
------------------------------------
25 33 55
00011001 = a
00100001 = b
00110111 = c
00001111 = xor
------------------------------------
25 34 56
00011001 = a
00100010 = b
00111000 = c
00000011 = xor
------------------------------------
25 35 61
00011001 = a
00100011 = b
00111101 = c
00000111 = xor
------------------------------------
25 36 62
00011001 = a
00100100 = b
00111110 = c
00000011 = xor
------------------------------------
25 37 59
00011001 = a
00100101 = b
00111011 = c
00000111 = xor
------------------------------------
25 38 60
00011001 = a
00100110 = b
00111100 = c
00000011 = xor
------------------------------------
25 39 49
00011001 = a
00100111 = b
00110001 = c
00001111 = xor
------------------------------------
25 40 50
00011001 = a
00101000 = b
00110010 = c
00000011 = xor
------------------------------------
25 41 47
00011001 = a
00101001 = b
00101111 = c
00011111 = xor
------------------------------------
25 42 48
00011001 = a
00101010 = b
00110000 = c
00000011 = xor
------------------------------------
25 43 53
00011001 = a
00101011 = b
00110101 = c
00000111 = xor
------------------------------------
25 44 54
00011001 = a
00101100 = b
00110110 = c
00000011 = xor
------------------------------------
25 45 51
00011001 = a
00101101 = b
00110011 = c
00000111 = xor
------------------------------------
25 46 52
00011001 = a
00101110 = b
00110100 = c
00000011 = xor
------------------------------------
25 63 89
00011001 = a
00111111 = b
01011001 = c
01111111 = xor
------------------------------------
25 64 90
00011001 = a
01000000 = b
01011010 = c
00000011 = xor
------------------------------------
25 65 87
00011001 = a
01000001 = b
01010111 = c
00001111 = xor
------------------------------------
25 66 88
00011001 = a
01000010 = b
01011000 = c
00000011 = xor
------------------------------------
25 67 93
00011001 = a
01000011 = b
01011101 = c
00000111 = xor
------------------------------------
25 68 94
00011001 = a
01000100 = b
01011110 = c
00000011 = xor
------------------------------------
25 69 91
00011001 = a
01000101 = b
01011011 = c
00000111 = xor
------------------------------------
25 70 92
00011001 = a
01000110 = b
01011100 = c
00000011 = xor
------------------------------------
25 71 81
00011001 = a
01000111 = b
01010001 = c
00001111 = xor
------------------------------------
25 72 82
00011001 = a
01001000 = b
01010010 = c
00000011 = xor
------------------------------------
25 73 79
00011001 = a
01001001 = b
01001111 = c
00011111 = xor
------------------------------------
25 74 80
00011001 = a
01001010 = b
01010000 = c
00000011 = xor
------------------------------------
25 75 85
00011001 = a
01001011 = b
01010101 = c
00000111 = xor
------------------------------------
25 76 86
00011001 = a
01001100 = b
01010110 = c
00000011 = xor
------------------------------------
25 77 83
00011001 = a
01001101 = b
01010011 = c
00000111 = xor
------------------------------------
25 78 84
00011001 = a
01001110 = b
01010100 = c
00000011 = xor
------------------------------------
26 31 58
00011010 = a
00011111 = b
00111010 = c
00111111 = xor
------------------------------------
26 32 57
00011010 = a
00100000 = b
00111001 = c
00000011 = xor
------------------------------------
26 33 56
00011010 = a
00100001 = b
00111000 = c
00000011 = xor
------------------------------------
26 34 55
00011010 = a
00100010 = b
00110111 = c
00001111 = xor
------------------------------------
26 35 62
00011010 = a
00100011 = b
00111110 = c
00000111 = xor
------------------------------------
26 36 61
00011010 = a
00100100 = b
00111101 = c
00000011 = xor
------------------------------------
26 37 60
00011010 = a
00100101 = b
00111100 = c
00000011 = xor
------------------------------------
26 38 59
00011010 = a
00100110 = b
00111011 = c
00000111 = xor
------------------------------------
26 39 50
00011010 = a
00100111 = b
00110010 = c
00001111 = xor
------------------------------------
26 40 49
00011010 = a
00101000 = b
00110001 = c
00000011 = xor
------------------------------------
26 41 48
00011010 = a
00101001 = b
00110000 = c
00000011 = xor
------------------------------------
26 42 47
00011010 = a
00101010 = b
00101111 = c
00011111 = xor
------------------------------------
26 43 54
00011010 = a
00101011 = b
00110110 = c
00000111 = xor
------------------------------------
26 44 53
00011010 = a
00101100 = b
00110101 = c
00000011 = xor
------------------------------------
26 45 52
00011010 = a
00101101 = b
00110100 = c
00000011 = xor
------------------------------------
26 46 51
00011010 = a
00101110 = b
00110011 = c
00000111 = xor
------------------------------------
26 63 90
00011010 = a
00111111 = b
01011010 = c
01111111 = xor
------------------------------------
26 64 89
00011010 = a
01000000 = b
01011001 = c
00000011 = xor
------------------------------------
26 65 88
00011010 = a
01000001 = b
01011000 = c
00000011 = xor
------------------------------------
26 66 87
00011010 = a
01000010 = b
01010111 = c
00001111 = xor
------------------------------------
26 67 94
00011010 = a
01000011 = b
01011110 = c
00000111 = xor
------------------------------------
26 68 93
00011010 = a
01000100 = b
01011101 = c
00000011 = xor
------------------------------------
26 69 92
00011010 = a
01000101 = b
01011100 = c
00000011 = xor
------------------------------------
26 70 91
00011010 = a
01000110 = b
01011011 = c
00000111 = xor
------------------------------------
26 71 82
00011010 = a
01000111 = b
01010010 = c
00001111 = xor
------------------------------------
26 72 81
00011010 = a
01001000 = b
01010001 = c
00000011 = xor
------------------------------------
26 73 80
00011010 = a
01001001 = b
01010000 = c
00000011 = xor
------------------------------------
26 74 79
00011010 = a
01001010 = b
01001111 = c
00011111 = xor
------------------------------------
26 75 86
00011010 = a
01001011 = b
01010110 = c
00000111 = xor
------------------------------------
26 76 85
00011010 = a
01001100 = b
01010101 = c
00000011 = xor
------------------------------------
26 77 84
00011010 = a
01001101 = b
01010100 = c
00000011 = xor
------------------------------------
26 78 83
00011010 = a
01001110 = b
01010011 = c
00000111 = xor
------------------------------------
27 31 59
00011011 = a
00011111 = b
00111011 = c
00111111 = xor
------------------------------------
27 32 60
00011011 = a
00100000 = b
00111100 = c
00000111 = xor
------------------------------------
27 33 61
00011011 = a
00100001 = b
00111101 = c
00000111 = xor
------------------------------------
27 34 62
00011011 = a
00100010 = b
00111110 = c
00000111 = xor
------------------------------------
27 35 55
00011011 = a
00100011 = b
00110111 = c
00001111 = xor
------------------------------------
27 36 56
00011011 = a
00100100 = b
00111000 = c
00000111 = xor
------------------------------------
27 37 57
00011011 = a
00100101 = b
00111001 = c
00000111 = xor
------------------------------------
27 38 58
00011011 = a
00100110 = b
00111010 = c
00000111 = xor
------------------------------------
27 39 51
00011011 = a
00100111 = b
00110011 = c
00001111 = xor
------------------------------------
27 40 52
00011011 = a
00101000 = b
00110100 = c
00000111 = xor
------------------------------------
27 41 53
00011011 = a
00101001 = b
00110101 = c
00000111 = xor
------------------------------------
27 42 54
00011011 = a
00101010 = b
00110110 = c
00000111 = xor
------------------------------------
27 43 47
00011011 = a
00101011 = b
00101111 = c
00011111 = xor
------------------------------------
27 44 48
00011011 = a
00101100 = b
00110000 = c
00000111 = xor
------------------------------------
27 45 49
00011011 = a
00101101 = b
00110001 = c
00000111 = xor
------------------------------------
27 46 50
00011011 = a
00101110 = b
00110010 = c
00000111 = xor
------------------------------------
27 63 91
00011011 = a
00111111 = b
01011011 = c
01111111 = xor
------------------------------------
27 64 92
00011011 = a
01000000 = b
01011100 = c
00000111 = xor
------------------------------------
27 65 93
00011011 = a
01000001 = b
01011101 = c
00000111 = xor
------------------------------------
27 66 94
00011011 = a
01000010 = b
01011110 = c
00000111 = xor
------------------------------------
27 67 87
00011011 = a
01000011 = b
01010111 = c
00001111 = xor
------------------------------------
27 68 88
00011011 = a
01000100 = b
01011000 = c
00000111 = xor
------------------------------------
27 69 89
00011011 = a
01000101 = b
01011001 = c
00000111 = xor
------------------------------------
27 70 90
00011011 = a
01000110 = b
01011010 = c
00000111 = xor
------------------------------------
27 71 83
00011011 = a
01000111 = b
01010011 = c
00001111 = xor
------------------------------------
27 72 84
00011011 = a
01001000 = b
01010100 = c
00000111 = xor
------------------------------------
27 73 85
00011011 = a
01001001 = b
01010101 = c
00000111 = xor
------------------------------------
27 74 86
00011011 = a
01001010 = b
01010110 = c
00000111 = xor
------------------------------------
27 75 79
00011011 = a
01001011 = b
01001111 = c
00011111 = xor
------------------------------------
27 76 80
00011011 = a
01001100 = b
01010000 = c
00000111 = xor
------------------------------------
27 77 81
00011011 = a
01001101 = b
01010001 = c
00000111 = xor
------------------------------------
27 78 82
00011011 = a
01001110 = b
01010010 = c
00000111 = xor
------------------------------------
28 31 60
00011100 = a
00011111 = b
00111100 = c
00111111 = xor
------------------------------------
28 32 59
00011100 = a
00100000 = b
00111011 = c
00000111 = xor
------------------------------------
28 33 62
00011100 = a
00100001 = b
00111110 = c
00000011 = xor
------------------------------------
28 34 61
00011100 = a
00100010 = b
00111101 = c
00000011 = xor
------------------------------------
28 35 56
00011100 = a
00100011 = b
00111000 = c
00000111 = xor
------------------------------------
28 36 55
00011100 = a
00100100 = b
00110111 = c
00001111 = xor
------------------------------------
28 37 58
00011100 = a
00100101 = b
00111010 = c
00000011 = xor
------------------------------------
28 38 57
00011100 = a
00100110 = b
00111001 = c
00000011 = xor
------------------------------------
28 39 52
00011100 = a
00100111 = b
00110100 = c
00001111 = xor
------------------------------------
28 40 51
00011100 = a
00101000 = b
00110011 = c
00000111 = xor
------------------------------------
28 41 54
00011100 = a
00101001 = b
00110110 = c
00000011 = xor
------------------------------------
28 42 53
00011100 = a
00101010 = b
00110101 = c
00000011 = xor
------------------------------------
28 43 48
00011100 = a
00101011 = b
00110000 = c
00000111 = xor
------------------------------------
28 44 47
00011100 = a
00101100 = b
00101111 = c
00011111 = xor
------------------------------------
28 45 50
00011100 = a
00101101 = b
00110010 = c
00000011 = xor
------------------------------------
28 46 49
00011100 = a
00101110 = b
00110001 = c
00000011 = xor
------------------------------------
28 63 92
00011100 = a
00111111 = b
01011100 = c
01111111 = xor
------------------------------------
28 64 91
00011100 = a
01000000 = b
01011011 = c
00000111 = xor
------------------------------------
28 65 94
00011100 = a
01000001 = b
01011110 = c
00000011 = xor
------------------------------------
28 66 93
00011100 = a
01000010 = b
01011101 = c
00000011 = xor
------------------------------------
28 67 88
00011100 = a
01000011 = b
01011000 = c
00000111 = xor
------------------------------------
28 68 87
00011100 = a
01000100 = b
01010111 = c
00001111 = xor
------------------------------------
28 69 90
00011100 = a
01000101 = b
01011010 = c
00000011 = xor
------------------------------------
28 70 89
00011100 = a
01000110 = b
01011001 = c
00000011 = xor
------------------------------------
28 71 84
00011100 = a
01000111 = b
01010100 = c
00001111 = xor
------------------------------------
28 72 83
00011100 = a
01001000 = b
01010011 = c
00000111 = xor
------------------------------------
28 73 86
00011100 = a
01001001 = b
01010110 = c
00000011 = xor
------------------------------------
28 74 85
00011100 = a
01001010 = b
01010101 = c
00000011 = xor
------------------------------------
28 75 80
00011100 = a
01001011 = b
01010000 = c
00000111 = xor
------------------------------------
28 76 79
00011100 = a
01001100 = b
01001111 = c
00011111 = xor
------------------------------------
28 77 82
00011100 = a
01001101 = b
01010010 = c
00000011 = xor
------------------------------------
28 78 81
00011100 = a
01001110 = b
01010001 = c
00000011 = xor
------------------------------------
29 31 61
00011101 = a
00011111 = b
00111101 = c
00111111 = xor
------------------------------------
29 32 62
00011101 = a
00100000 = b
00111110 = c
00000011 = xor
------------------------------------
29 33 59
00011101 = a
00100001 = b
00111011 = c
00000111 = xor
------------------------------------
29 34 60
00011101 = a
00100010 = b
00111100 = c
00000011 = xor
------------------------------------
29 35 57
00011101 = a
00100011 = b
00111001 = c
00000111 = xor
------------------------------------
29 36 58
00011101 = a
00100100 = b
00111010 = c
00000011 = xor
------------------------------------
29 37 55
00011101 = a
00100101 = b
00110111 = c
00001111 = xor
------------------------------------
29 38 56
00011101 = a
00100110 = b
00111000 = c
00000011 = xor
------------------------------------
29 39 53
00011101 = a
00100111 = b
00110101 = c
00001111 = xor
------------------------------------
29 40 54
00011101 = a
00101000 = b
00110110 = c
00000011 = xor
------------------------------------
29 41 51
00011101 = a
00101001 = b
00110011 = c
00000111 = xor
------------------------------------
29 42 52
00011101 = a
00101010 = b
00110100 = c
00000011 = xor
------------------------------------
29 43 49
00011101 = a
00101011 = b
00110001 = c
00000111 = xor
------------------------------------
29 44 50
00011101 = a
00101100 = b
00110010 = c
00000011 = xor
------------------------------------
29 45 47
00011101 = a
00101101 = b
00101111 = c
00011111 = xor
------------------------------------
29 46 48
00011101 = a
00101110 = b
00110000 = c
00000011 = xor
------------------------------------
29 63 93
00011101 = a
00111111 = b
01011101 = c
01111111 = xor
------------------------------------
29 64 94
00011101 = a
01000000 = b
01011110 = c
00000011 = xor
------------------------------------
29 65 91
00011101 = a
01000001 = b
01011011 = c
00000111 = xor
------------------------------------
29 66 92
00011101 = a
01000010 = b
01011100 = c
00000011 = xor
------------------------------------
29 67 89
00011101 = a
01000011 = b
01011001 = c
00000111 = xor
------------------------------------
29 68 90
00011101 = a
01000100 = b
01011010 = c
00000011 = xor
------------------------------------
29 69 87
00011101 = a
01000101 = b
01010111 = c
00001111 = xor
------------------------------------
29 70 88
00011101 = a
01000110 = b
01011000 = c
00000011 = xor
------------------------------------
29 71 85
00011101 = a
01000111 = b
01010101 = c
00001111 = xor
------------------------------------
29 72 86
00011101 = a
01001000 = b
01010110 = c
00000011 = xor
------------------------------------
29 73 83
00011101 = a
01001001 = b
01010011 = c
00000111 = xor
------------------------------------
29 74 84
00011101 = a
01001010 = b
01010100 = c
00000011 = xor
------------------------------------
29 75 81
00011101 = a
01001011 = b
01010001 = c
00000111 = xor
------------------------------------
29 76 82
00011101 = a
01001100 = b
01010010 = c
00000011 = xor
------------------------------------
29 77 79
00011101 = a
01001101 = b
01001111 = c
00011111 = xor
------------------------------------
29 78 80
00011101 = a
01001110 = b
01010000 = c
00000011 = xor
------------------------------------
30 31 62
00011110 = a
00011111 = b
00111110 = c
00111111 = xor
------------------------------------
30 32 61
00011110 = a
00100000 = b
00111101 = c
00000011 = xor
------------------------------------
30 33 60
00011110 = a
00100001 = b
00111100 = c
00000011 = xor
------------------------------------
30 34 59
00011110 = a
00100010 = b
00111011 = c
00000111 = xor
------------------------------------
30 35 58
00011110 = a
00100011 = b
00111010 = c
00000111 = xor
------------------------------------
30 36 57
00011110 = a
00100100 = b
00111001 = c
00000011 = xor
------------------------------------
30 37 56
00011110 = a
00100101 = b
00111000 = c
00000011 = xor
------------------------------------
30 38 55
00011110 = a
00100110 = b
00110111 = c
00001111 = xor
------------------------------------
30 39 54
00011110 = a
00100111 = b
00110110 = c
00001111 = xor
------------------------------------
30 40 53
00011110 = a
00101000 = b
00110101 = c
00000011 = xor
------------------------------------
30 41 52
00011110 = a
00101001 = b
00110100 = c
00000011 = xor
------------------------------------
30 42 51
00011110 = a
00101010 = b
00110011 = c
00000111 = xor
------------------------------------
30 43 50
00011110 = a
00101011 = b
00110010 = c
00000111 = xor
------------------------------------
30 44 49
00011110 = a
00101100 = b
00110001 = c
00000011 = xor
------------------------------------
30 45 48
00011110 = a
00101101 = b
00110000 = c
00000011 = xor
------------------------------------
30 46 47
00011110 = a
00101110 = b
00101111 = c
00011111 = xor
------------------------------------
30 63 94
00011110 = a
00111111 = b
01011110 = c
01111111 = xor
------------------------------------
30 64 93
00011110 = a
01000000 = b
01011101 = c
00000011 = xor
------------------------------------
30 65 92
00011110 = a
01000001 = b
01011100 = c
00000011 = xor
------------------------------------
30 66 91
00011110 = a
01000010 = b
01011011 = c
00000111 = xor
------------------------------------
30 67 90
00011110 = a
01000011 = b
01011010 = c
00000111 = xor
------------------------------------
30 68 89
00011110 = a
01000100 = b
01011001 = c
00000011 = xor
------------------------------------
30 69 88
00011110 = a
01000101 = b
01011000 = c
00000011 = xor
------------------------------------
30 70 87
00011110 = a
01000110 = b
01010111 = c
00001111 = xor
------------------------------------
30 71 86
00011110 = a
01000111 = b
01010110 = c
00001111 = xor
------------------------------------
30 72 85
00011110 = a
01001000 = b
01010101 = c
00000011 = xor
------------------------------------
30 73 84
00011110 = a
01001001 = b
01010100 = c
00000011 = xor
------------------------------------
30 74 83
00011110 = a
01001010 = b
01010011 = c
00000111 = xor
------------------------------------
30 75 82
00011110 = a
01001011 = b
01010010 = c
00000111 = xor
------------------------------------
30 76 81
00011110 = a
01001100 = b
01010001 = c
00000011 = xor
------------------------------------
30 77 80
00011110 = a
01001101 = b
01010000 = c
00000011 = xor
------------------------------------
30 78 79
00011110 = a
01001110 = b
01001111 = c
00011111 = xor
------------------------------------
31 63 95
00011111 = a
00111111 = b
01011111 = c
01111111 = xor
------------------------------------
31 64 96
00011111 = a
01000000 = b
01100000 = c
00111111 = xor
------------------------------------
31 65 97
00011111 = a
01000001 = b
01100001 = c
00111111 = xor
------------------------------------
31 66 98
00011111 = a
01000010 = b
01100010 = c
00111111 = xor
------------------------------------
31 67 99
00011111 = a
01000011 = b
01100011 = c
00111111 = xor
------------------------------------
31 68 100
00011111 = a
01000100 = b
01100100 = c
00111111 = xor
------------------------------------
32 63 96
00100000 = a
00111111 = b
01100000 = c
01111111 = xor
------------------------------------
32 64 95
00100000 = a
01000000 = b
01011111 = c
00111111 = xor
------------------------------------
32 65 98
00100000 = a
01000001 = b
01100010 = c
00000011 = xor
------------------------------------
32 66 97
00100000 = a
01000010 = b
01100001 = c
00000011 = xor
------------------------------------
32 67 100
00100000 = a
01000011 = b
01100100 = c
00000111 = xor
------------------------------------
32 68 99
00100000 = a
01000100 = b
01100011 = c
00000111 = xor
------------------------------------
33 63 97
00100001 = a
00111111 = b
01100001 = c
01111111 = xor
------------------------------------
33 64 98
00100001 = a
01000000 = b
01100010 = c
00000011 = xor
------------------------------------
33 65 95
00100001 = a
01000001 = b
01011111 = c
00111111 = xor
------------------------------------
33 66 96
00100001 = a
01000010 = b
01100000 = c
00000011 = xor
------------------------------------
33 69 99
00100001 = a
01000101 = b
01100011 = c
00000111 = xor
------------------------------------
33 70 100
00100001 = a
01000110 = b
01100100 = c
00000011 = xor
------------------------------------
34 63 98
00100010 = a
00111111 = b
01100010 = c
01111111 = xor
------------------------------------
34 64 97
00100010 = a
01000000 = b
01100001 = c
00000011 = xor
------------------------------------
34 65 96
00100010 = a
01000001 = b
01100000 = c
00000011 = xor
------------------------------------
34 66 95
00100010 = a
01000010 = b
01011111 = c
00111111 = xor
------------------------------------
34 69 100
00100010 = a
01000101 = b
01100100 = c
00000011 = xor
------------------------------------
34 70 99
00100010 = a
01000110 = b
01100011 = c
00000111 = xor
------------------------------------
35 63 99
00100011 = a
00111111 = b
01100011 = c
01111111 = xor
------------------------------------
35 64 100
00100011 = a
01000000 = b
01100100 = c
00000111 = xor
------------------------------------
35 67 95
00100011 = a
01000011 = b
01011111 = c
00111111 = xor
------------------------------------
35 68 96
00100011 = a
01000100 = b
01100000 = c
00000111 = xor
------------------------------------
35 69 97
00100011 = a
01000101 = b
01100001 = c
00000111 = xor
------------------------------------
35 70 98
00100011 = a
01000110 = b
01100010 = c
00000111 = xor
------------------------------------
36 63 100
00100100 = a
00111111 = b
01100100 = c
01111111 = xor
------------------------------------
36 64 99
00100100 = a
01000000 = b
01100011 = c
00000111 = xor
------------------------------------
36 67 96
00100100 = a
01000011 = b
01100000 = c
00000111 = xor
------------------------------------
36 68 95
00100100 = a
01000100 = b
01011111 = c
00111111 = xor
------------------------------------
36 69 98
00100100 = a
01000101 = b
01100010 = c
00000011 = xor
------------------------------------
36 70 97
00100100 = a
01000110 = b
01100001 = c
00000011 = xor
------------------------------------
37 65 99
00100101 = a
01000001 = b
01100011 = c
00000111 = xor
------------------------------------
37 66 100
00100101 = a
01000010 = b
01100100 = c
00000011 = xor
------------------------------------
37 67 97
00100101 = a
01000011 = b
01100001 = c
00000111 = xor
------------------------------------
37 68 98
00100101 = a
01000100 = b
01100010 = c
00000011 = xor
------------------------------------
37 69 95
00100101 = a
01000101 = b
01011111 = c
00111111 = xor
------------------------------------
37 70 96
00100101 = a
01000110 = b
01100000 = c
00000011 = xor
------------------------------------
38 65 100
00100110 = a
01000001 = b
01100100 = c
00000011 = xor
------------------------------------
38 66 99
00100110 = a
01000010 = b
01100011 = c
00000111 = xor
------------------------------------
38 67 98
00100110 = a
01000011 = b
01100010 = c
00000111 = xor
------------------------------------
38 68 97
00100110 = a
01000100 = b
01100001 = c
00000011 = xor
------------------------------------
38 69 96
00100110 = a
01000101 = b
01100000 = c
00000011 = xor
------------------------------------
38 70 95
00100110 = a
01000110 = b
01011111 = c
00111111 = xor
------------------------------------
39 71 95
00100111 = a
01000111 = b
01011111 = c
00111111 = xor
------------------------------------
39 72 96
00100111 = a
01001000 = b
01100000 = c
00001111 = xor
------------------------------------
39 73 97
00100111 = a
01001001 = b
01100001 = c
00001111 = xor
------------------------------------
39 74 98
00100111 = a
01001010 = b
01100010 = c
00001111 = xor
------------------------------------
39 75 99
00100111 = a
01001011 = b
01100011 = c
00001111 = xor
------------------------------------
39 76 100
00100111 = a
01001100 = b
01100100 = c
00001111 = xor
------------------------------------
40 71 96
00101000 = a
01000111 = b
01100000 = c
00001111 = xor
------------------------------------
40 72 95
00101000 = a
01001000 = b
01011111 = c
00111111 = xor
------------------------------------
40 73 98
00101000 = a
01001001 = b
01100010 = c
00000011 = xor
------------------------------------
40 74 97
00101000 = a
01001010 = b
01100001 = c
00000011 = xor
------------------------------------
40 75 100
00101000 = a
01001011 = b
01100100 = c
00000111 = xor
------------------------------------
40 76 99
00101000 = a
01001100 = b
01100011 = c
00000111 = xor
------------------------------------
41 71 97
00101001 = a
01000111 = b
01100001 = c
00001111 = xor
------------------------------------
41 72 98
00101001 = a
01001000 = b
01100010 = c
00000011 = xor
------------------------------------
41 73 95
00101001 = a
01001001 = b
01011111 = c
00111111 = xor
------------------------------------
41 74 96
00101001 = a
01001010 = b
01100000 = c
00000011 = xor
------------------------------------
41 77 99
00101001 = a
01001101 = b
01100011 = c
00000111 = xor
------------------------------------
41 78 100
00101001 = a
01001110 = b
01100100 = c
00000011 = xor
------------------------------------
42 71 98
00101010 = a
01000111 = b
01100010 = c
00001111 = xor
------------------------------------
42 72 97
00101010 = a
01001000 = b
01100001 = c
00000011 = xor
------------------------------------
42 73 96
00101010 = a
01001001 = b
01100000 = c
00000011 = xor
------------------------------------
42 74 95
00101010 = a
01001010 = b
01011111 = c
00111111 = xor
------------------------------------
42 77 100
00101010 = a
01001101 = b
01100100 = c
00000011 = xor
------------------------------------
42 78 99
00101010 = a
01001110 = b
01100011 = c
00000111 = xor
------------------------------------
43 71 99
00101011 = a
01000111 = b
01100011 = c
00001111 = xor
------------------------------------
43 72 100
00101011 = a
01001000 = b
01100100 = c
00000111 = xor
------------------------------------
43 75 95
00101011 = a
01001011 = b
01011111 = c
00111111 = xor
------------------------------------
43 76 96
00101011 = a
01001100 = b
01100000 = c
00000111 = xor
------------------------------------
43 77 97
00101011 = a
01001101 = b
01100001 = c
00000111 = xor
------------------------------------
43 78 98
00101011 = a
01001110 = b
01100010 = c
00000111 = xor
------------------------------------
44 71 100
00101100 = a
01000111 = b
01100100 = c
00001111 = xor
------------------------------------
44 72 99
00101100 = a
01001000 = b
01100011 = c
00000111 = xor
------------------------------------
44 75 96
00101100 = a
01001011 = b
01100000 = c
00000111 = xor
------------------------------------
44 76 95
00101100 = a
01001100 = b
01011111 = c
00111111 = xor
------------------------------------
44 77 98
00101100 = a
01001101 = b
01100010 = c
00000011 = xor
------------------------------------
44 78 97
00101100 = a
01001110 = b
01100001 = c
00000011 = xor
------------------------------------
45 73 99
00101101 = a
01001001 = b
01100011 = c
00000111 = xor
------------------------------------
45 74 100
00101101 = a
01001010 = b
01100100 = c
00000011 = xor
------------------------------------
45 75 97
00101101 = a
01001011 = b
01100001 = c
00000111 = xor
------------------------------------
45 76 98
00101101 = a
01001100 = b
01100010 = c
00000011 = xor
------------------------------------
45 77 95
00101101 = a
01001101 = b
01011111 = c
00111111 = xor
------------------------------------
45 78 96
00101101 = a
01001110 = b
01100000 = c
00000011 = xor
------------------------------------
46 73 100
00101110 = a
01001001 = b
01100100 = c
00000011 = xor
------------------------------------
46 74 99
00101110 = a
01001010 = b
01100011 = c
00000111 = xor
------------------------------------
46 75 98
00101110 = a
01001011 = b
01100010 = c
00000111 = xor
------------------------------------
46 76 97
00101110 = a
01001100 = b
01100001 = c
00000011 = xor
------------------------------------
46 77 96
00101110 = a
01001101 = b
01100000 = c
00000011 = xor
------------------------------------
46 78 95
00101110 = a
01001110 = b
01011111 = c
00111111 = xor
------------------------------------
47 79 95
00101111 = a
01001111 = b
01011111 = c
00111111 = xor
------------------------------------
47 80 96
00101111 = a
01010000 = b
01100000 = c
00011111 = xor
------------------------------------
47 81 97
00101111 = a
01010001 = b
01100001 = c
00011111 = xor
------------------------------------
47 82 98
00101111 = a
01010010 = b
01100010 = c
00011111 = xor
------------------------------------
47 83 99
00101111 = a
01010011 = b
01100011 = c
00011111 = xor
------------------------------------
47 84 100
00101111 = a
01010100 = b
01100100 = c
00011111 = xor
------------------------------------
48 79 96
00110000 = a
01001111 = b
01100000 = c
00011111 = xor
------------------------------------
48 80 95
00110000 = a
01010000 = b
01011111 = c
00111111 = xor
------------------------------------
48 81 98
00110000 = a
01010001 = b
01100010 = c
00000011 = xor
------------------------------------
48 82 97
00110000 = a
01010010 = b
01100001 = c
00000011 = xor
------------------------------------
48 83 100
00110000 = a
01010011 = b
01100100 = c
00000111 = xor
------------------------------------
48 84 99
00110000 = a
01010100 = b
01100011 = c
00000111 = xor
------------------------------------
49 79 97
00110001 = a
01001111 = b
01100001 = c
00011111 = xor
------------------------------------
49 80 98
00110001 = a
01010000 = b
01100010 = c
00000011 = xor
------------------------------------
49 81 95
00110001 = a
01010001 = b
01011111 = c
00111111 = xor
------------------------------------
49 82 96
00110001 = a
01010010 = b
01100000 = c
00000011 = xor
------------------------------------
49 85 99
00110001 = a
01010101 = b
01100011 = c
00000111 = xor
------------------------------------
49 86 100
00110001 = a
01010110 = b
01100100 = c
00000011 = xor
------------------------------------
50 79 98
00110010 = a
01001111 = b
01100010 = c
00011111 = xor
------------------------------------
50 80 97
00110010 = a
01010000 = b
01100001 = c
00000011 = xor
------------------------------------
50 81 96
00110010 = a
01010001 = b
01100000 = c
00000011 = xor
------------------------------------
50 82 95
00110010 = a
01010010 = b
01011111 = c
00111111 = xor
------------------------------------
50 85 100
00110010 = a
01010101 = b
01100100 = c
00000011 = xor
------------------------------------
50 86 99
00110010 = a
01010110 = b
01100011 = c
00000111 = xor
------------------------------------
51 79 99
00110011 = a
01001111 = b
01100011 = c
00011111 = xor
------------------------------------
51 80 100
00110011 = a
01010000 = b
01100100 = c
00000111 = xor
------------------------------------
51 83 95
00110011 = a
01010011 = b
01011111 = c
00111111 = xor
------------------------------------
51 84 96
00110011 = a
01010100 = b
01100000 = c
00000111 = xor
------------------------------------
51 85 97
00110011 = a
01010101 = b
01100001 = c
00000111 = xor
------------------------------------
51 86 98
00110011 = a
01010110 = b
01100010 = c
00000111 = xor
------------------------------------
52 79 100
00110100 = a
01001111 = b
01100100 = c
00011111 = xor
------------------------------------
52 80 99
00110100 = a
01010000 = b
01100011 = c
00000111 = xor
------------------------------------
52 83 96
00110100 = a
01010011 = b
01100000 = c
00000111 = xor
------------------------------------
52 84 95
00110100 = a
01010100 = b
01011111 = c
00111111 = xor
------------------------------------
52 85 98
00110100 = a
01010101 = b
01100010 = c
00000011 = xor
------------------------------------
52 86 97
00110100 = a
01010110 = b
01100001 = c
00000011 = xor
------------------------------------
53 81 99
00110101 = a
01010001 = b
01100011 = c
00000111 = xor
------------------------------------
53 82 100
00110101 = a
01010010 = b
01100100 = c
00000011 = xor
------------------------------------
53 83 97
00110101 = a
01010011 = b
01100001 = c
00000111 = xor
------------------------------------
53 84 98
00110101 = a
01010100 = b
01100010 = c
00000011 = xor
------------------------------------
53 85 95
00110101 = a
01010101 = b
01011111 = c
00111111 = xor
------------------------------------
53 86 96
00110101 = a
01010110 = b
01100000 = c
00000011 = xor
------------------------------------
54 81 100
00110110 = a
01010001 = b
01100100 = c
00000011 = xor
------------------------------------
54 82 99
00110110 = a
01010010 = b
01100011 = c
00000111 = xor
------------------------------------
54 83 98
00110110 = a
01010011 = b
01100010 = c
00000111 = xor
------------------------------------
54 84 97
00110110 = a
01010100 = b
01100001 = c
00000011 = xor
------------------------------------
54 85 96
00110110 = a
01010101 = b
01100000 = c
00000011 = xor
------------------------------------
54 86 95
00110110 = a
01010110 = b
01011111 = c
00111111 = xor
------------------------------------
55 87 95
00110111 = a
01010111 = b
01011111 = c
00111111 = xor
------------------------------------
55 88 96
00110111 = a
01011000 = b
01100000 = c
00001111 = xor
------------------------------------
55 89 97
00110111 = a
01011001 = b
01100001 = c
00001111 = xor
------------------------------------
55 90 98
00110111 = a
01011010 = b
01100010 = c
00001111 = xor
------------------------------------
55 91 99
00110111 = a
01011011 = b
01100011 = c
00001111 = xor
------------------------------------
55 92 100
00110111 = a
01011100 = b
01100100 = c
00001111 = xor
------------------------------------
56 87 96
00111000 = a
01010111 = b
01100000 = c
00001111 = xor
------------------------------------
56 88 95
00111000 = a
01011000 = b
01011111 = c
00111111 = xor
------------------------------------
56 89 98
00111000 = a
01011001 = b
01100010 = c
00000011 = xor
------------------------------------
56 90 97
00111000 = a
01011010 = b
01100001 = c
00000011 = xor
------------------------------------
56 91 100
00111000 = a
01011011 = b
01100100 = c
00000111 = xor
------------------------------------
56 92 99
00111000 = a
01011100 = b
01100011 = c
00000111 = xor
------------------------------------
57 87 97
00111001 = a
01010111 = b
01100001 = c
00001111 = xor
------------------------------------
57 88 98
00111001 = a
01011000 = b
01100010 = c
00000011 = xor
------------------------------------
57 89 95
00111001 = a
01011001 = b
01011111 = c
00111111 = xor
------------------------------------
57 90 96
00111001 = a
01011010 = b
01100000 = c
00000011 = xor
------------------------------------
57 93 99
00111001 = a
01011101 = b
01100011 = c
00000111 = xor
------------------------------------
57 94 100
00111001 = a
01011110 = b
01100100 = c
00000011 = xor
------------------------------------
58 87 98
00111010 = a
01010111 = b
01100010 = c
00001111 = xor
------------------------------------
58 88 97
00111010 = a
01011000 = b
01100001 = c
00000011 = xor
------------------------------------
58 89 96
00111010 = a
01011001 = b
01100000 = c
00000011 = xor
------------------------------------
58 90 95
00111010 = a
01011010 = b
01011111 = c
00111111 = xor
------------------------------------
58 93 100
00111010 = a
01011101 = b
01100100 = c
00000011 = xor
------------------------------------
58 94 99
00111010 = a
01011110 = b
01100011 = c
00000111 = xor
------------------------------------
59 87 99
00111011 = a
01010111 = b
01100011 = c
00001111 = xor
------------------------------------
59 88 100
00111011 = a
01011000 = b
01100100 = c
00000111 = xor
------------------------------------
59 91 95
00111011 = a
01011011 = b
01011111 = c
00111111 = xor
------------------------------------
59 92 96
00111011 = a
01011100 = b
01100000 = c
00000111 = xor
------------------------------------
59 93 97
00111011 = a
01011101 = b
01100001 = c
00000111 = xor
------------------------------------
59 94 98
00111011 = a
01011110 = b
01100010 = c
00000111 = xor
------------------------------------
60 87 100
00111100 = a
01010111 = b
01100100 = c
00001111 = xor
------------------------------------
60 88 99
00111100 = a
01011000 = b
01100011 = c
00000111 = xor
------------------------------------
60 91 96
00111100 = a
01011011 = b
01100000 = c
00000111 = xor
------------------------------------
60 92 95
00111100 = a
01011100 = b
01011111 = c
00111111 = xor
------------------------------------
60 93 98
00111100 = a
01011101 = b
01100010 = c
00000011 = xor
------------------------------------
60 94 97
00111100 = a
01011110 = b
01100001 = c
00000011 = xor
------------------------------------
61 89 99
00111101 = a
01011001 = b
01100011 = c
00000111 = xor
------------------------------------
61 90 100
00111101 = a
01011010 = b
01100100 = c
00000011 = xor
------------------------------------
61 91 97
00111101 = a
01011011 = b
01100001 = c
00000111 = xor
------------------------------------
61 92 98
00111101 = a
01011100 = b
01100010 = c
00000011 = xor
------------------------------------
61 93 95
00111101 = a
01011101 = b
01011111 = c
00111111 = xor
------------------------------------
61 94 96
00111101 = a
01011110 = b
01100000 = c
00000011 = xor
------------------------------------
62 89 100
00111110 = a
01011001 = b
01100100 = c
00000011 = xor
------------------------------------
62 90 99
00111110 = a
01011010 = b
01100011 = c
00000111 = xor
------------------------------------
62 91 98
00111110 = a
01011011 = b
01100010 = c
00000111 = xor
------------------------------------
62 92 97
00111110 = a
01011100 = b
01100001 = c
00000011 = xor
------------------------------------
62 93 96
00111110 = a
01011101 = b
01100000 = c
00000011 = xor
------------------------------------
62 94 95
00111110 = a
01011110 = b
01011111 = c
00111111 = xor