+- Forums - Open Redstone Engineers (https://forum.openredstone.org)
+-- Forum: Off-Topic (https://forum.openredstone.org/forum-4.html)
+--- Forum: Programming (https://forum.openredstone.org/forum-8.html)
+--- Thread: using c++ to come up with hex XOR (/thread-9538.html)
using c++ to come up with hex XOR - Magic :^) - 03-11-2016
so I'm bruteforcing some stuff using comparator subtraction logic to look for patterns that will let me do XOR.
I've been able to use subtraction and inversion to achieve an XOR equivalent function on all possible values except for when there is a combination of two from the following list:
3: 0011
5: 0101
6: 0110
9: 1001
10: 1010
12: 1100
It's pretty interesting how the problematic values always contain 2 bits.
Here is the code i rigged up to mess with stuff:
Code:
#include <iostream>
using namespace std;
class ComparatorBasic{
public:
ComparatorBasic(int input = 0x0, int sideA = 0x0, int sideB = 0x0){
in(input);
side(sideA, sideB);
}
int out(){return _round(_in-_side);}
void in(int val){
_in = _round(val);
return;
}
void side(int a){
side(a, 0x0);
return;
}
void side(int a, int b){
if(a>=b) _side = _round(a);
else _side = _round(b);
return;
}
private:
int _in;
int _side;
int _round(int val){
if(val<0x0) return 0x0;
else if(val>0xF) return 0xF;
else return val;
}
};
class Comparator{
public:
Comparator(int val = 0x0){_value = ComparatorBasic(val).out();}
Comparator operator-(Comparator val){
return Comparator(ComparatorBasic(_value, val.value()).out());
}
Comparator operator-(int val){
return operator-(Comparator(val));
}
Comparator operator!(){
return Comparator(0xF)-_value;
}
Comparator operator+(Comparator val){
return !(!val - _value);
}
Comparator operator+(int val){
return operator+(Comparator(val));
}
void operator=(Comparator val){
_value = val.value();
return;
}
void operator=(int val){
_value = ComparatorBasic(val).out();
return;
}
void operator+=(Comparator val){
operator=(operator+(val));
return;
}
void operator+=(int val){
return operator+=(Comparator(val));
}
bool operator==(Comparator val){
return _value==val.value();
}
bool operator==(int val){
return _value==val;
}
int value(){return _value;}
void bin(){
for(int i=8; i>0; i/=2) cout << bool(_value&i);
return;
}
private:
int _value;
};
void test(Comparator A, Comparator B){
Comparator val[2][2] = {
A, !A,
B, !B,
};
Comparator target = A.value()^B.value();
bool success = false;
for(int i=0; i<2; i++){
for(int j=0; j<2; j++){
for(int k=0; k<2; k++){
Comparator result = val[i][j] - val[i^1][k];
if((result == target)||(!result == target)){
success = true;
if(!result == target) cout << "!(";
if(j) cout << '!';
val[i][0].bin();
cout << " - ";
if(k) cout << '!';
val[i^1][0].bin();
if(!result == target) cout << ')';
cout << " == ";
A.bin();
cout << " ^ ";
B.bin();
cout << endl;
}
}
}
}
if(!success){
cout << "Unable to acheive XOR for ";
A.bin();
cout << " ^ ";
B.bin();
cout << endl;
}
return;
}
int main(){
for(int i=0; i<16; i++){
for(int j=i; j<16; j++){
test(Comparator(i), Comparator(j));
}
}
return 0;
}http://pbin.in/hax
... and yes I overloaded ! to be hex inversion, don't kill me D:
RE: using c++ to come up with hex XOR - Magic :^) - 03-11-2016
I dealt with the special cases by subtracting 1 and now all XOR operations are accounted for :^)
Here's some new test code, with a lot of false positives stripped out so everything's narrowed down to 1 to 3 solutions each
http://pbin.in/moreHax
program output:
Code:
Testing 0000 ^ 0000...
0000 - 0000 == 0000 ^ 0000
!(!0000 - 0000) == 0000 ^ 0000
!0000 - !0000 == 0000 ^ 0000
Testing 0001 ^ 0000...
0001 - 0000 == 0001 ^ 0000
!(!0001 - 0000) == 0001 ^ 0000
Testing 0010 ^ 0000...
0010 - 0000 == 0010 ^ 0000
!(!0010 - 0000) == 0010 ^ 0000
Testing 0011 ^ 0000...
0011 - 0000 == 0011 ^ 0000
!(!0011 - 0000) == 0011 ^ 0000
Testing 0100 ^ 0000...
0100 - 0000 == 0100 ^ 0000
!(!0100 - 0000) == 0100 ^ 0000
Testing 0101 ^ 0000...
0101 - 0000 == 0101 ^ 0000
!(!0101 - 0000) == 0101 ^ 0000
Testing 0110 ^ 0000...
0110 - 0000 == 0110 ^ 0000
!(!0110 - 0000) == 0110 ^ 0000
Testing 0111 ^ 0000...
0111 - 0000 == 0111 ^ 0000
!(!0111 - 0000) == 0111 ^ 0000
Testing 1000 ^ 0000...
!(1000 - 0000) == 1000 ^ 0000
!(!1000 - 0000) == 1000 ^ 0000
Testing 1001 ^ 0000...
1001 - 0000 == 1001 ^ 0000
!(!1001 - 0000) == 1001 ^ 0000
Testing 1010 ^ 0000...
1010 - 0000 == 1010 ^ 0000
!(!1010 - 0000) == 1010 ^ 0000
Testing 1011 ^ 0000...
1011 - 0000 == 1011 ^ 0000
!(!1011 - 0000) == 1011 ^ 0000
Testing 1100 ^ 0000...
1100 - 0000 == 1100 ^ 0000
!(!1100 - 0000) == 1100 ^ 0000
Testing 1101 ^ 0000...
1101 - 0000 == 1101 ^ 0000
!(!1101 - 0000) == 1101 ^ 0000
Testing 1110 ^ 0000...
1110 - 0000 == 1110 ^ 0000
!(!1110 - 0000) == 1110 ^ 0000
Testing 1111 ^ 0000...
1111 - 0000 == 1111 ^ 0000
!(1111 - !0000) == 1111 ^ 0000
!(!1111 - 0000) == 1111 ^ 0000
Testing 0001 ^ 0001...
0001 - 0001 == 0001 ^ 0001
!0001 - !0001 == 0001 ^ 0001
Testing 0010 ^ 0001...
!(!0010 - 0001) == 0010 ^ 0001
Testing 0011 ^ 0001...
0011 - 0001 == 0011 ^ 0001
Testing 0100 ^ 0001...
!(!0100 - 0001) == 0100 ^ 0001
Testing 0101 ^ 0001...
0101 - 0001 == 0101 ^ 0001
Testing 0110 ^ 0001...
!(!0110 - 0001) == 0110 ^ 0001
Testing 0111 ^ 0001...
0111 - 0001 == 0111 ^ 0001
!0111 - 0001 - 0001 == 0111 ^ 0001
Testing 1000 ^ 0001...
!(1000 - 0001 - 0001) == 1000 ^ 0001
!(!1000 - 0001) == 1000 ^ 0001
Testing 1001 ^ 0001...
!(1001 - 0001) == 1001 ^ 0001
Testing 1010 ^ 0001...
!(!1010 - 0001) == 1010 ^ 0001
Testing 1011 ^ 0001...
1011 - 0001 == 1011 ^ 0001
Testing 1100 ^ 0001...
!(!1100 - 0001) == 1100 ^ 0001
Testing 1101 ^ 0001...
1101 - 0001 == 1101 ^ 0001
Testing 1110 ^ 0001...
!(1110 - !0001) == 1110 ^ 0001
!(!1110 - 0001) == 1110 ^ 0001
Testing 1111 ^ 0001...
1111 - 0001 == 1111 ^ 0001
!(1111 - !0001) == 1111 ^ 0001
Testing 0010 ^ 0010...
0010 - 0010 == 0010 ^ 0010
!0010 - !0010 == 0010 ^ 0010
Testing 0011 ^ 0010...
0011 - 0010 == 0011 ^ 0010
Testing 0100 ^ 0010...
!(!0100 - 0010) == 0100 ^ 0010
Testing 0101 ^ 0010...
!(!0101 - 0010) == 0101 ^ 0010
Testing 0110 ^ 0010...
0110 - 0010 == 0110 ^ 0010
Testing 0111 ^ 0010...
0111 - 0010 == 0111 ^ 0010
!0111 - 0010 - 0001 == 0111 ^ 0010
Testing 1000 ^ 0010...
!(1000 - 0010 - 0001) == 1000 ^ 0010
!(!1000 - 0010) == 1000 ^ 0010
Testing 1001 ^ 0010...
!(!1001 - 0010) == 1001 ^ 0010
Testing 1010 ^ 0010...
!(1010 - 0010) == 1010 ^ 0010
Testing 1011 ^ 0010...
1011 - 0010 == 1011 ^ 0010
Testing 1100 ^ 0010...
!(!1100 - 0010) == 1100 ^ 0010
Testing 1101 ^ 0010...
!(1101 - !0010) == 1101 ^ 0010
!(!1101 - 0010) == 1101 ^ 0010
Testing 1110 ^ 0010...
1110 - 0010 == 1110 ^ 0010
Testing 1111 ^ 0010...
1111 - 0010 == 1111 ^ 0010
!(1111 - !0010) == 1111 ^ 0010
Testing 0011 ^ 0011...
0011 - 0011 == 0011 ^ 0011
!0011 - !0011 == 0011 ^ 0011
Testing 0100 ^ 0011...
!(!0100 - 0011) == 0100 ^ 0011
Testing 0101 ^ 0011...
!0101 - 0011 - 0001 == 0101 ^ 0011
Testing 0110 ^ 0011...
!0110 - 0011 - 0001 == 0110 ^ 0011
Testing 0111 ^ 0011...
0111 - 0011 == 0111 ^ 0011
!0111 - 0011 - 0001 == 0111 ^ 0011
Testing 1000 ^ 0011...
!(1000 - 0011 - 0001) == 1000 ^ 0011
!(!1000 - 0011) == 1000 ^ 0011
Testing 1001 ^ 0011...
!(1001 - 0011 - 0001) == 1001 ^ 0011
Testing 1010 ^ 0011...
!(1010 - 0011 - 0001) == 1010 ^ 0011
Testing 1011 ^ 0011...
!(1011 - 0011) == 1011 ^ 0011
Testing 1100 ^ 0011...
!(1100 - !0011) == 1100 ^ 0011
!(!1100 - 0011) == 1100 ^ 0011
Testing 1101 ^ 0011...
!(1101 - !0011) == 1101 ^ 0011
Testing 1110 ^ 0011...
!(1110 - !0011) == 1110 ^ 0011
Testing 1111 ^ 0011...
1111 - 0011 == 1111 ^ 0011
!(1111 - !0011) == 1111 ^ 0011
Testing 0100 ^ 0100...
0100 - 0100 == 0100 ^ 0100
!0100 - !0100 == 0100 ^ 0100
Testing 0101 ^ 0100...
0101 - 0100 == 0101 ^ 0100
Testing 0110 ^ 0100...
0110 - 0100 == 0110 ^ 0100
Testing 0111 ^ 0100...
0111 - 0100 == 0111 ^ 0100
!0111 - 0100 - 0001 == 0111 ^ 0100
Testing 1000 ^ 0100...
!(1000 - 0100 - 0001) == 1000 ^ 0100
!(!1000 - 0100) == 1000 ^ 0100
Testing 1001 ^ 0100...
!(!1001 - 0100) == 1001 ^ 0100
Testing 1010 ^ 0100...
!(!1010 - 0100) == 1010 ^ 0100
Testing 1011 ^ 0100...
!(1011 - !0100) == 1011 ^ 0100
!(!1011 - 0100) == 1011 ^ 0100
Testing 1100 ^ 0100...
!(1100 - 0100) == 1100 ^ 0100
Testing 1101 ^ 0100...
1101 - 0100 == 1101 ^ 0100
Testing 1110 ^ 0100...
1110 - 0100 == 1110 ^ 0100
Testing 1111 ^ 0100...
1111 - 0100 == 1111 ^ 0100
!(1111 - !0100) == 1111 ^ 0100
Testing 0101 ^ 0101...
0101 - 0101 == 0101 ^ 0101
!0101 - !0101 == 0101 ^ 0101
Testing 0110 ^ 0101...
!0110 - 0101 - 0001 == 0110 ^ 0101
Testing 0111 ^ 0101...
0111 - 0101 == 0111 ^ 0101
!0111 - 0101 - 0001 == 0111 ^ 0101
Testing 1000 ^ 0101...
!(1000 - 0101 - 0001) == 1000 ^ 0101
!(!1000 - 0101) == 1000 ^ 0101
Testing 1001 ^ 0101...
!(1001 - 0101 - 0001) == 1001 ^ 0101
Testing 1010 ^ 0101...
!(1010 - !0101) == 1010 ^ 0101
!(!1010 - 0101) == 1010 ^ 0101
Testing 1011 ^ 0101...
!(1011 - !0101) == 1011 ^ 0101
Testing 1100 ^ 0101...
!(1100 - 0101 - 0001) == 1100 ^ 0101
Testing 1101 ^ 0101...
!(1101 - 0101) == 1101 ^ 0101
Testing 1110 ^ 0101...
!(1110 - !0101) == 1110 ^ 0101
Testing 1111 ^ 0101...
1111 - 0101 == 1111 ^ 0101
!(1111 - !0101) == 1111 ^ 0101
Testing 0110 ^ 0110...
0110 - 0110 == 0110 ^ 0110
!0110 - !0110 == 0110 ^ 0110
Testing 0111 ^ 0110...
0111 - 0110 == 0111 ^ 0110
!0111 - 0110 - 0001 == 0111 ^ 0110
Testing 1000 ^ 0110...
!(1000 - 0110 - 0001) == 1000 ^ 0110
!(!1000 - 0110) == 1000 ^ 0110
Testing 1001 ^ 0110...
!(1001 - !0110) == 1001 ^ 0110
!(!1001 - 0110) == 1001 ^ 0110
Testing 1010 ^ 0110...
!(1010 - 0110 - 0001) == 1010 ^ 0110
Testing 1011 ^ 0110...
!(1011 - !0110) == 1011 ^ 0110
Testing 1100 ^ 0110...
!(1100 - 0110 - 0001) == 1100 ^ 0110
Testing 1101 ^ 0110...
!(1101 - !0110) == 1101 ^ 0110
Testing 1110 ^ 0110...
!(1110 - 0110) == 1110 ^ 0110
Testing 1111 ^ 0110...
1111 - 0110 == 1111 ^ 0110
!(1111 - !0110) == 1111 ^ 0110
Testing 0111 ^ 0111...
0111 - 0111 == 0111 ^ 0111
!0111 - 0111 - 0001 == 0111 ^ 0111
!0111 - !0111 == 0111 ^ 0111
Testing 1000 ^ 0111...
!(1000 - 0111 - 0001) == 1000 ^ 0111
!(1000 - !0111) == 1000 ^ 0111
!(!1000 - 0111) == 1000 ^ 0111
Testing 1001 ^ 0111...
!(1001 - 0111 - 0001) == 1001 ^ 0111
!(1001 - !0111) == 1001 ^ 0111
Testing 1010 ^ 0111...
!(1010 - 0111 - 0001) == 1010 ^ 0111
!(1010 - !0111) == 1010 ^ 0111
Testing 1011 ^ 0111...
!(1011 - 0111 - 0001) == 1011 ^ 0111
!(1011 - !0111) == 1011 ^ 0111
Testing 1100 ^ 0111...
!(1100 - 0111 - 0001) == 1100 ^ 0111
!(1100 - !0111) == 1100 ^ 0111
Testing 1101 ^ 0111...
!(1101 - 0111 - 0001) == 1101 ^ 0111
!(1101 - !0111) == 1101 ^ 0111
Testing 1110 ^ 0111...
!(1110 - 0111 - 0001) == 1110 ^ 0111
!(1110 - !0111) == 1110 ^ 0111
Testing 1111 ^ 0111...
!(1111 - 0111) == 1111 ^ 0111
!(1111 - !0111) == 1111 ^ 0111
Testing 1000 ^ 1000...
1000 - 1000 == 1000 ^ 1000
1000 - !1000 - 0001 == 1000 ^ 1000
!1000 - !1000 == 1000 ^ 1000
Testing 1001 ^ 1000...
1001 - 1000 == 1001 ^ 1000
1001 - !1000 - 0001 == 1001 ^ 1000
Testing 1010 ^ 1000...
1010 - 1000 == 1010 ^ 1000
1010 - !1000 - 0001 == 1010 ^ 1000
Testing 1011 ^ 1000...
1011 - 1000 == 1011 ^ 1000
1011 - !1000 - 0001 == 1011 ^ 1000
Testing 1100 ^ 1000...
1100 - 1000 == 1100 ^ 1000
1100 - !1000 - 0001 == 1100 ^ 1000
Testing 1101 ^ 1000...
1101 - 1000 == 1101 ^ 1000
1101 - !1000 - 0001 == 1101 ^ 1000
Testing 1110 ^ 1000...
1110 - 1000 == 1110 ^ 1000
1110 - !1000 - 0001 == 1110 ^ 1000
Testing 1111 ^ 1000...
1111 - 1000 == 1111 ^ 1000
!(1111 - !1000) == 1111 ^ 1000
Testing 1001 ^ 1001...
1001 - 1001 == 1001 ^ 1001
!1001 - !1001 == 1001 ^ 1001
Testing 1010 ^ 1001...
1010 - !1001 - 0001 == 1010 ^ 1001
Testing 1011 ^ 1001...
1011 - 1001 == 1011 ^ 1001
Testing 1100 ^ 1001...
1100 - !1001 - 0001 == 1100 ^ 1001
Testing 1101 ^ 1001...
1101 - 1001 == 1101 ^ 1001
Testing 1110 ^ 1001...
!(1110 - !1001) == 1110 ^ 1001
Testing 1111 ^ 1001...
1111 - 1001 == 1111 ^ 1001
!(1111 - !1001) == 1111 ^ 1001
Testing 1010 ^ 1010...
1010 - 1010 == 1010 ^ 1010
!1010 - !1010 == 1010 ^ 1010
Testing 1011 ^ 1010...
1011 - 1010 == 1011 ^ 1010
Testing 1100 ^ 1010...
1100 - !1010 - 0001 == 1100 ^ 1010
Testing 1101 ^ 1010...
!(1101 - !1010) == 1101 ^ 1010
Testing 1110 ^ 1010...
1110 - 1010 == 1110 ^ 1010
Testing 1111 ^ 1010...
1111 - 1010 == 1111 ^ 1010
!(1111 - !1010) == 1111 ^ 1010
Testing 1011 ^ 1011...
1011 - 1011 == 1011 ^ 1011
!1011 - !1011 == 1011 ^ 1011
Testing 1100 ^ 1011...
!(1100 - !1011) == 1100 ^ 1011
Testing 1101 ^ 1011...
!(1101 - !1011) == 1101 ^ 1011
Testing 1110 ^ 1011...
!(1110 - !1011) == 1110 ^ 1011
Testing 1111 ^ 1011...
1111 - 1011 == 1111 ^ 1011
!(1111 - !1011) == 1111 ^ 1011
Testing 1100 ^ 1100...
1100 - 1100 == 1100 ^ 1100
!1100 - !1100 == 1100 ^ 1100
Testing 1101 ^ 1100...
1101 - 1100 == 1101 ^ 1100
Testing 1110 ^ 1100...
1110 - 1100 == 1110 ^ 1100
Testing 1111 ^ 1100...
1111 - 1100 == 1111 ^ 1100
!(1111 - !1100) == 1111 ^ 1100
Testing 1101 ^ 1101...
1101 - 1101 == 1101 ^ 1101
!1101 - !1101 == 1101 ^ 1101
Testing 1110 ^ 1101...
!(1110 - !1101) == 1110 ^ 1101
Testing 1111 ^ 1101...
1111 - 1101 == 1111 ^ 1101
!(1111 - !1101) == 1111 ^ 1101
Testing 1110 ^ 1110...
1110 - 1110 == 1110 ^ 1110
!1110 - !1110 == 1110 ^ 1110
Testing 1111 ^ 1110...
1111 - 1110 == 1111 ^ 1110
!(1111 - !1110) == 1111 ^ 1110
Testing 1111 ^ 1111...
1111 - 1111 == 1111 ^ 1111
!(1111 - !1111) == 1111 ^ 1111
!1111 - !1111 == 1111 ^ 1111RE: using c++ to come up with hex XOR - Nuuppanaani - 03-11-2016
cheats
RE: using c++ to come up with hex XOR - Magic :^) - 03-15-2016
narrowed down comparator XOR to 6 unique operations
http://pbin.in/haxTheHax
here's the output now:
Code:
Testing 0000 ^ 0000...
add
sub
subiB-1
Testing 0001 ^ 0000...
add
sub
Testing 0010 ^ 0000...
add
sub
Testing 0011 ^ 0000...
add
sub
Testing 0100 ^ 0000...
add
sub
Testing 0101 ^ 0000...
add
sub
Testing 0110 ^ 0000...
add
sub
Testing 0111 ^ 0000...
add
sub
!(add+1)
Testing 1000 ^ 0000...
add
sub
!(sub-1)
Testing 1001 ^ 0000...
add
sub
Testing 1010 ^ 0000...
add
sub
Testing 1011 ^ 0000...
add
sub
Testing 1100 ^ 0000...
add
sub
Testing 1101 ^ 0000...
add
sub
Testing 1110 ^ 0000...
add
sub
Testing 1111 ^ 0000...
add
sub
!subiB
Testing 0001 ^ 0001...
sub
subiB-1
Testing 0010 ^ 0001...
add
Testing 0011 ^ 0001...
sub
Testing 0100 ^ 0001...
add
Testing 0101 ^ 0001...
sub
Testing 0110 ^ 0001...
add
!(add+1)
Testing 0111 ^ 0001...
sub
!(add+1)
Testing 1000 ^ 0001...
add
!(sub-1)
Testing 1001 ^ 0001...
sub
!(sub-1)
Testing 1010 ^ 0001...
add
Testing 1011 ^ 0001...
sub
Testing 1100 ^ 0001...
add
Testing 1101 ^ 0001...
sub
Testing 1110 ^ 0001...
add
!subiB
Testing 1111 ^ 0001...
sub
!subiB
Testing 0010 ^ 0010...
sub
subiB-1
Testing 0011 ^ 0010...
sub
Testing 0100 ^ 0010...
add
Testing 0101 ^ 0010...
add
!(add+1)
Testing 0110 ^ 0010...
sub
Testing 0111 ^ 0010...
sub
!(add+1)
Testing 1000 ^ 0010...
add
!(sub-1)
Testing 1001 ^ 0010...
add
Testing 1010 ^ 0010...
sub
!(sub-1)
Testing 1011 ^ 0010...
sub
Testing 1100 ^ 0010...
add
Testing 1101 ^ 0010...
add
!subiB
Testing 1110 ^ 0010...
sub
Testing 1111 ^ 0010...
sub
!subiB
Testing 0011 ^ 0011...
sub
subiB-1
Testing 0100 ^ 0011...
add
!(add+1)
Testing 0101 ^ 0011...
!(add+1)
Testing 0110 ^ 0011...
!(add+1)
Testing 0111 ^ 0011...
sub
!(add+1)
Testing 1000 ^ 0011...
add
!(sub-1)
Testing 1001 ^ 0011...
!(sub-1)
Testing 1010 ^ 0011...
!(sub-1)
Testing 1011 ^ 0011...
sub
!(sub-1)
Testing 1100 ^ 0011...
add
!subiB
Testing 1101 ^ 0011...
!subiB
Testing 1110 ^ 0011...
!subiB
Testing 1111 ^ 0011...
sub
!subiB
Testing 0100 ^ 0100...
sub
subiB-1
Testing 0101 ^ 0100...
sub
Testing 0110 ^ 0100...
sub
Testing 0111 ^ 0100...
sub
!(add+1)
Testing 1000 ^ 0100...
add
!(sub-1)
Testing 1001 ^ 0100...
add
Testing 1010 ^ 0100...
add
Testing 1011 ^ 0100...
add
!subiB
Testing 1100 ^ 0100...
sub
!(sub-1)
Testing 1101 ^ 0100...
sub
Testing 1110 ^ 0100...
sub
Testing 1111 ^ 0100...
sub
!subiB
Testing 0101 ^ 0101...
sub
subiB-1
Testing 0110 ^ 0101...
!(add+1)
Testing 0111 ^ 0101...
sub
!(add+1)
Testing 1000 ^ 0101...
add
!(sub-1)
Testing 1001 ^ 0101...
!(sub-1)
Testing 1010 ^ 0101...
add
!subiB
Testing 1011 ^ 0101...
!subiB
Testing 1100 ^ 0101...
!(sub-1)
Testing 1101 ^ 0101...
sub
!(sub-1)
Testing 1110 ^ 0101...
!subiB
Testing 1111 ^ 0101...
sub
!subiB
Testing 0110 ^ 0110...
sub
subiB-1
Testing 0111 ^ 0110...
sub
!(add+1)
Testing 1000 ^ 0110...
add
!(sub-1)
Testing 1001 ^ 0110...
add
!subiB
Testing 1010 ^ 0110...
!(sub-1)
Testing 1011 ^ 0110...
!subiB
Testing 1100 ^ 0110...
!(sub-1)
Testing 1101 ^ 0110...
!subiB
Testing 1110 ^ 0110...
sub
!(sub-1)
Testing 1111 ^ 0110...
sub
!subiB
Testing 0111 ^ 0111...
sub
!(add+1)
subiB-1
Testing 1000 ^ 0111...
add
!subiB
!(sub-1)
Testing 1001 ^ 0111...
!subiB
!(sub-1)
Testing 1010 ^ 0111...
!subiB
!(sub-1)
Testing 1011 ^ 0111...
!subiB
!(sub-1)
Testing 1100 ^ 0111...
!subiB
!(sub-1)
Testing 1101 ^ 0111...
!subiB
!(sub-1)
Testing 1110 ^ 0111...
!subiB
!(sub-1)
Testing 1111 ^ 0111...
sub
!subiB
!(sub-1)
Testing 1000 ^ 1000...
sub
!(add+1)
subiB-1
Testing 1001 ^ 1000...
sub
subiB-1
Testing 1010 ^ 1000...
sub
subiB-1
Testing 1011 ^ 1000...
sub
subiB-1
Testing 1100 ^ 1000...
sub
subiB-1
Testing 1101 ^ 1000...
sub
subiB-1
Testing 1110 ^ 1000...
sub
subiB-1
Testing 1111 ^ 1000...
sub
!subiB
subiB-1
Testing 1001 ^ 1001...
sub
!(add+1)
Testing 1010 ^ 1001...
subiB-1
Testing 1011 ^ 1001...
sub
Testing 1100 ^ 1001...
subiB-1
Testing 1101 ^ 1001...
sub
Testing 1110 ^ 1001...
!subiB
subiB-1
Testing 1111 ^ 1001...
sub
!subiB
Testing 1010 ^ 1010...
sub
!(add+1)
Testing 1011 ^ 1010...
sub
Testing 1100 ^ 1010...
subiB-1
Testing 1101 ^ 1010...
!subiB
subiB-1
Testing 1110 ^ 1010...
sub
Testing 1111 ^ 1010...
sub
!subiB
Testing 1011 ^ 1011...
sub
!(add+1)
Testing 1100 ^ 1011...
!subiB
subiB-1
Testing 1101 ^ 1011...
!subiB
Testing 1110 ^ 1011...
!subiB
Testing 1111 ^ 1011...
sub
!subiB
Testing 1100 ^ 1100...
sub
!(add+1)
Testing 1101 ^ 1100...
sub
Testing 1110 ^ 1100...
sub
Testing 1111 ^ 1100...
sub
!subiB
Testing 1101 ^ 1101...
sub
!(add+1)
Testing 1110 ^ 1101...
!subiB
Testing 1111 ^ 1101...
sub
!subiB
Testing 1110 ^ 1110...
sub
!(add+1)
Testing 1111 ^ 1110...
sub
!subiB
Testing 1111 ^ 1111...
sub
!subiB
!(add+1)
Necessary operations:
add
sub
!subiB
!(add+1)
!(sub-1)
subiB-1add is shorthand for A+B
sub is shorthand for A-B
subiB is shorthand for A-!B
Also everything works under the assumption that A>=B atm. Maybe I'll rework it later so that the order doesn't matter.