fom - 03 - connectivity algebra

[fom]

By removing a line and its associated
line elements from a projective geometry,
one obtains an affine geometry.

The lines of a 21-point plane each have
5 line elements.

Every corresponding affine geometry is
a 16-point plane for which each line
has 4 line elements.

What follows is a faithful algebra of
intensional functions ("intensional" as
described by Church when introducing
the lambda-calculus) associated with
16 of logical constants that form
an affine plane in the namespace and
having the signature:

<16, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2>

with domain:

{LEQ, OR, DENY, FLIP, NIF, NTRU, AND, NIMP, XOR, IMP, NAND, TRU, IF,
FIX, LET, NOR}



(I am sorry. I have been accused of not
understanding the meaning of "formal")


and axioms:


LEQ (LEQ,LEQ) = TRU
LEQ (LEQ,OR) = AND
LEQ (LEQ,DENY) = FLIP
LEQ (LEQ,FLIP) = DENY
LEQ (LEQ,NIF) = NIMP
LEQ (LEQ,NTRU) = XOR
LEQ (LEQ,AND) = OR
LEQ (LEQ,NIMP) = NIF
LEQ (LEQ,XOR) = NTRU
LEQ (LEQ,IMP) = IF
LEQ (LEQ,NAND) = NOR
LEQ (LEQ,TRU) = LEQ
LEQ (LEQ,IF) = IMP
LEQ (LEQ,FIX) = LET
LEQ (LEQ,LET) = FIX
LEQ (LEQ,NOR) = NAND
LEQ (OR,LEQ) = AND
LEQ (OR,OR) = TRU
LEQ (OR,DENY) = NIMP
LEQ (OR,FLIP) = NIF
LEQ (OR,NIF) = FLIP
LEQ (OR,NTRU) = NOR
LEQ (OR,AND) = LEQ
LEQ (OR,NIMP) = DENY
LEQ (OR,XOR) = NAND
LEQ (OR,IMP) = LET
LEQ (OR,NAND) = XOR
LEQ (OR,TRU) = OR
LEQ (OR,IF) = FIX
LEQ (OR,FIX) = IF
LEQ (OR,LET) = IMP
LEQ (OR,NOR) = NTRU
LEQ (DENY,LEQ) = FLIP
LEQ (DENY,OR) = NIMP
LEQ (DENY,DENY) = TRU
LEQ (DENY,FLIP) = LEQ
LEQ (DENY,NIF) = AND
LEQ (DENY,NTRU) = LET
LEQ (DENY,AND) = NIF
LEQ (DENY,NIMP) = OR
LEQ (DENY,XOR) = FIX
LEQ (DENY,IMP) = NOR
LEQ (DENY,NAND) = IF
LEQ (DENY,TRU) = DENY
LEQ (DENY,IF) = NAND
LEQ (DENY,FIX) = XOR
LEQ (DENY,LET) = NTRU
LEQ (DENY,NOR) = IMP
LEQ (FLIP,LEQ) = DENY
LEQ (FLIP,OR) = NIF
LEQ (FLIP,DENY) = LEQ
LEQ (FLIP,FLIP) = TRU
LEQ (FLIP,NIF) = OR
LEQ (FLIP,NTRU) = FIX
LEQ (FLIP,AND) = NIMP
LEQ (FLIP,NIMP) = AND
LEQ (FLIP,XOR) = LET
LEQ (FLIP,IMP) = NAND
LEQ (FLIP,NAND) = IMP
LEQ (FLIP,TRU) = FLIP
LEQ (FLIP,IF) = NOR
LEQ (FLIP,FIX) = NTRU
LEQ (FLIP,LET) = XOR
LEQ (FLIP,NOR) = IF
LEQ (NIF,LEQ) = NIMP
LEQ (NIF,OR) = FLIP
LEQ (NIF,DENY) = AND
LEQ (NIF,FLIP) = OR
LEQ (NIF,NIF) = TRU
LEQ (NIF,NTRU) = IF
LEQ (NIF,AND) = DENY
LEQ (NIF,NIMP) = LEQ
LEQ (NIF,XOR) = IMP
LEQ (NIF,IMP) = XOR
LEQ (NIF,NAND) = LET
LEQ (NIF,TRU) = NIF
LEQ (NIF,IF) = NTRU
LEQ (NIF,FIX) = NOR
LEQ (NIF,LET) = NAND
LEQ (NIF,NOR) = FIX
LEQ (NTRU,LEQ) = XOR
LEQ (NTRU,OR) = NOR
LEQ (NTRU,DENY) = LET
LEQ (NTRU,FLIP) = FIX
LEQ (NTRU,NIF) = IF
LEQ (NTRU,NTRU) = TRU
LEQ (NTRU,AND) = NAND
LEQ (NTRU,NIMP) = IMP
LEQ (NTRU,XOR) = LEQ
LEQ (NTRU,IMP) = NIMP
LEQ (NTRU,NAND) = AND
LEQ (NTRU,TRU) = NTRU
LEQ (NTRU,IF) = NIF
LEQ (NTRU,FIX) = FLIP
LEQ (NTRU,LET) = DENY
LEQ (NTRU,NOR) = OR
LEQ (AND,LEQ) = OR
LEQ (AND,OR) = LEQ
LEQ (AND,DENY) = NIF
LEQ (AND,FLIP) = NIMP
LEQ (AND,NIF) = DENY
LEQ (AND,NTRU) = NAND
LEQ (AND,AND) = TRU
LEQ (AND,NIMP) = FLIP
LEQ (AND,XOR) = NOR
LEQ (AND,IMP) = FIX
LEQ (AND,NAND) = NTRU
LEQ (AND,TRU) = AND
LEQ (AND,IF) = LET
LEQ (AND,FIX) = IMP
LEQ (AND,LET) = IF
LEQ (AND,NOR) = XOR
LEQ (NIMP,LEQ) = NIF
LEQ (NIMP,OR) = DENY
LEQ (NIMP,DENY) = OR
LEQ (NIMP,FLIP) = AND
LEQ (NIMP,NIF) = LEQ
LEQ (NIMP,NTRU) = IMP
LEQ (NIMP,AND) = FLIP
LEQ (NIMP,NIMP) = TRU
LEQ (NIMP,XOR) = IF
LEQ (NIMP,IMP) = NTRU
LEQ (NIMP,NAND) = FIX
LEQ (NIMP,TRU) = NIMP
LEQ (NIMP,IF) = XOR
LEQ (NIMP,FIX) = NAND
LEQ (NIMP,LET) = NOR
LEQ (NIMP,NOR) = LET
LEQ (XOR,LEQ) = NTRU
LEQ (XOR,OR) = NAND
LEQ (XOR,DENY) = FIX
LEQ (XOR,FLIP) = LET
LEQ (XOR,NIF) = IMP
LEQ (XOR,NTRU) = LEQ
LEQ (XOR,AND) = NOR
LEQ (XOR,NIMP) = IF
LEQ (XOR,XOR) = TRU
LEQ (XOR,IMP) = NIF
LEQ (XOR,NAND) = OR
LEQ (XOR,TRU) = XOR
LEQ (XOR,IF) = NIMP
LEQ (XOR,FIX) = DENY
LEQ (XOR,LET) = FLIP
LEQ (XOR,NOR) = AND
LEQ (IMP,LEQ) = IF
LEQ (IMP,OR) = LET
LEQ (IMP,DENY) = NOR
LEQ (IMP,FLIP) = NAND
LEQ (IMP,NIF) = XOR
LEQ (IMP,NTRU) = NIMP
LEQ (IMP,AND) = FIX
LEQ (IMP,NIMP) = NTRU
LEQ (IMP,XOR) = NIF
LEQ (IMP,IMP) = TRU
LEQ (IMP,NAND) = FLIP
LEQ (IMP,TRU) = IMP
LEQ (IMP,IF) = LEQ
LEQ (IMP,FIX) = AND
LEQ (IMP,LET) = OR
LEQ (IMP,NOR) = DENY
LEQ (NAND,LEQ) = NOR
LEQ (NAND,OR) = XOR
LEQ (NAND,DENY) = IF
LEQ (NAND,FLIP) = IMP
LEQ (NAND,NIF) = LET
LEQ (NAND,NTRU) = AND
LEQ (NAND,AND) = NTRU
LEQ (NAND,NIMP) = FIX
LEQ (NAND,XOR) = OR
LEQ (NAND,IMP) = FLIP
LEQ (NAND,NAND) = TRU
LEQ (NAND,TRU) = NAND
LEQ (NAND,IF) = DENY
LEQ (NAND,FIX) = NIMP
LEQ (NAND,LET) = NIF
LEQ (NAND,NOR) = LEQ
LEQ (TRU,LEQ) = LEQ
LEQ (TRU,OR) = OR
LEQ (TRU,DENY) = DENY
LEQ (TRU,FLIP) = FLIP
LEQ (TRU,NIF) = NIF
LEQ (TRU,NTRU) = NTRU
LEQ (TRU,AND) = AND
LEQ (TRU,NIMP) = NIMP
LEQ (TRU,XOR) = XOR
LEQ (TRU,IMP) = IMP
LEQ (TRU,NAND) = NAND
LEQ (TRU,TRU) = TRU
LEQ (TRU,IF) = IF
LEQ (TRU,FIX) = FIX
LEQ (TRU,LET) = LET
LEQ (TRU,NOR) = NOR
LEQ (IF,LEQ) = IMP
LEQ (IF,OR) = FIX
LEQ (IF,DENY) = NAND
LEQ (IF,FLIP) = NOR
LEQ (IF,NIF) = NTRU
LEQ (IF,NTRU) = NIF
LEQ (IF,AND) = LET
LEQ (IF,NIMP) = XOR
LEQ (IF,XOR) = NIMP
LEQ (IF,IMP) = LEQ
LEQ (IF,NAND) = DENY
LEQ (IF,TRU) = IF
LEQ (IF,IF) = TRU
LEQ (IF,FIX) = OR
LEQ (IF,LET) = AND
LEQ (IF,NOR) = FLIP
LEQ (FIX,LEQ) = LET
LEQ (FIX,OR) = IF
LEQ (FIX,DENY) = XOR
LEQ (FIX,FLIP) = NTRU
LEQ (FIX,NIF) = NOR
LEQ (FIX,NTRU) = FLIP
LEQ (FIX,AND) = IMP
LEQ (FIX,NIMP) = NAND
LEQ (FIX,XOR) = DENY
LEQ (FIX,IMP) = AND
LEQ (FIX,NAND) = NIMP
LEQ (FIX,TRU) = FIX
LEQ (FIX,IF) = OR
LEQ (FIX,FIX) = TRU
LEQ (FIX,LET) = LEQ
LEQ (FIX,NOR) = NIF
LEQ (LET,LEQ) = FIX
LEQ (LET,OR) = IMP
LEQ (LET,DENY) = NTRU
LEQ (LET,FLIP) = XOR
LEQ (LET,NIF) = NAND
LEQ (LET,NTRU) = DENY
LEQ (LET,AND) = IF
LEQ (LET,NIMP) = NOR
LEQ (LET,XOR) = FLIP
LEQ (LET,IMP) = OR
LEQ (LET,NAND) = NIF
LEQ (LET,TRU) = LET
LEQ (LET,IF) = AND
LEQ (LET,FIX) = LEQ
LEQ (LET,LET) = TRU
LEQ (LET,NOR) = NIMP
LEQ (NOR,LEQ) = NAND
LEQ (NOR,OR) = NTRU
LEQ (NOR,DENY) = IMP
LEQ (NOR,FLIP) = IF
LEQ (NOR,NIF) = FIX
LEQ (NOR,NTRU) = OR
LEQ (NOR,AND) = XOR
LEQ (NOR,NIMP) = LET
LEQ (NOR,XOR) = AND
LEQ (NOR,IMP) = DENY
LEQ (NOR,NAND) = LEQ
LEQ (NOR,TRU) = NOR
LEQ (NOR,IF) = FLIP
LEQ (NOR,FIX) = NIF
LEQ (NOR,LET) = NIMP
LEQ (NOR,NOR) = TRU
OR (LEQ,LEQ) = LEQ
OR (LEQ,OR) = TRU
OR (LEQ,DENY) = IF
OR (LEQ,FLIP) = IMP
OR (LEQ,NIF) = IMP
OR (LEQ,NTRU) = LEQ
OR (LEQ,AND) = LEQ
OR (LEQ,NIMP) = IF
OR (LEQ,XOR) = TRU
OR (LEQ,IMP) = IMP
OR (LEQ,NAND) = TRU
OR (LEQ,TRU) = TRU
OR (LEQ,IF) = IF
OR (LEQ,FIX) = IF
OR (LEQ,LET) = IMP
OR (LEQ,NOR) = LEQ
OR (OR,LEQ) = TRU
OR (OR,OR) = OR
OR (OR,DENY) = TRU
OR (OR,FLIP) = TRU
OR (OR,NIF) = OR
OR (OR,NTRU) = OR
OR (OR,AND) = OR
OR (OR,NIMP) = OR
OR (OR,XOR) = OR
OR (OR,IMP) = TRU
OR (OR,NAND) = TRU
OR (OR,TRU) = TRU
OR (OR,IF) = TRU
OR (OR,FIX) = OR
OR (OR,LET) = OR
OR (OR,NOR) = TRU
OR (DENY,LEQ) = IF
OR (DENY,OR) = TRU
OR (DENY,DENY) = DENY
OR (DENY,FLIP) = NAND
OR (DENY,NIF) = NAND
OR (DENY,NTRU) = DENY
OR (DENY,AND) = IF
OR (DENY,NIMP) = DENY
OR (DENY,XOR) = NAND
OR (DENY,IMP) = TRU
OR (DENY,NAND) = NAND
OR (DENY,TRU) = TRU
OR (DENY,IF) = IF
OR (DENY,FIX) = IF
OR (DENY,LET) = TRU
OR (DENY,NOR) = DENY
OR (FLIP,LEQ) = IMP
OR (FLIP,OR) = TRU
OR (FLIP,DENY) = NAND
OR (FLIP,FLIP) = FLIP
OR (FLIP,NIF) = FLIP
OR (FLIP,NTRU) = FLIP
OR (FLIP,AND) = IMP
OR (FLIP,NIMP) = NAND
OR (FLIP,XOR) = NAND
OR (FLIP,IMP) = IMP
OR (FLIP,NAND) = NAND
OR (FLIP,TRU) = TRU
OR (FLIP,IF) = TRU
OR (FLIP,FIX) = TRU
OR (FLIP,LET) = IMP
OR (FLIP,NOR) = FLIP
OR (NIF,LEQ) = IMP
OR (NIF,OR) = OR
OR (NIF,DENY) = NAND
OR (NIF,FLIP) = FLIP
OR (NIF,NIF) = NIF
OR (NIF,NTRU) = NIF
OR (NIF,AND) = LET
OR (NIF,NIMP) = XOR
OR (NIF,XOR) = XOR
OR (NIF,IMP) = IMP
OR (NIF,NAND) = NAND
OR (NIF,TRU) = TRU
OR (NIF,IF) = TRU
OR (NIF,FIX) = OR
OR (NIF,LET) = LET
OR (NIF,NOR) = FLIP
OR (NTRU,LEQ) = LEQ
OR (NTRU,OR) = OR
OR (NTRU,DENY) = DENY
OR (NTRU,FLIP) = FLIP
OR (NTRU,NIF) = NIF
OR (NTRU,NTRU) = NTRU
OR (NTRU,AND) = AND
OR (NTRU,NIMP) = NIMP
OR (NTRU,XOR) = XOR
OR (NTRU,IMP) = IMP
OR (NTRU,NAND) = NAND
OR (NTRU,TRU) = TRU
OR (NTRU,IF) = IF
OR (NTRU,FIX) = FIX
OR (NTRU,LET) = LET
OR (NTRU,NOR) = NOR
OR (AND,LEQ) = LEQ
OR (AND,OR) = OR
OR (AND,DENY) = IF
OR (AND,FLIP) = IMP
OR (AND,NIF) = LET
OR (AND,NTRU) = AND
OR (AND,AND) = AND
OR (AND,NIMP) = FIX
OR (AND,XOR) = OR
OR (AND,IMP) = IMP
OR (AND,NAND) = TRU
OR (AND,TRU) = TRU
OR (AND,IF) = IF
OR (AND,FIX) = FIX
OR (AND,LET) = LET
OR (AND,NOR) = LEQ
OR (NIMP,LEQ) = IF
OR (NIMP,OR) = OR
OR (NIMP,DENY) = DENY
OR (NIMP,FLIP) = NAND
OR (NIMP,NIF) = XOR
OR (NIMP,NTRU) = NIMP
OR (NIMP,AND) = FIX
OR (NIMP,NIMP) = NIMP
OR (NIMP,XOR) = XOR
OR (NIMP,IMP) = TRU
OR (NIMP,NAND) = NAND
OR (NIMP,TRU) = TRU
OR (NIMP,IF) = IF
OR (NIMP,FIX) = FIX
OR (NIMP,LET) = OR
OR (NIMP,NOR) = DENY
OR (XOR,LEQ) = TRU
OR (XOR,OR) = OR
OR (XOR,DENY) = NAND
OR (XOR,FLIP) = NAND
OR (XOR,NIF) = XOR
OR (XOR,NTRU) = XOR
OR (XOR,AND) = OR
OR (XOR,NIMP) = XOR
OR (XOR,XOR) = XOR
OR (XOR,IMP) = TRU
OR (XOR,NAND) = NAND
OR (XOR,TRU) = TRU
OR (XOR,IF) = TRU
OR (XOR,FIX) = OR
OR (XOR,LET) = OR
OR (XOR,NOR) = NAND
OR (IMP,LEQ) = IMP
OR (IMP,OR) = TRU
OR (IMP,DENY) = TRU
OR (IMP,FLIP) = IMP
OR (IMP,NIF) = IMP
OR (IMP,NTRU) = IMP
OR (IMP,AND) = IMP
OR (IMP,NIMP) = TRU
OR (IMP,XOR) = TRU
OR (IMP,IMP) = IMP
OR (IMP,NAND) = TRU
OR (IMP,TRU) = TRU
OR (IMP,IF) = TRU
OR (IMP,FIX) = TRU
OR (IMP,LET) = IMP
OR (IMP,NOR) = IMP
OR (NAND,LEQ) = TRU
OR (NAND,OR) = TRU
OR (NAND,DENY) = NAND
OR (NAND,FLIP) = NAND
OR (NAND,NIF) = NAND
OR (NAND,NTRU) = NAND
OR (NAND,AND) = TRU
OR (NAND,NIMP) = NAND
OR (NAND,XOR) = NAND
OR (NAND,IMP) = TRU
OR (NAND,NAND) = NAND
OR (NAND,TRU) = TRU
OR (NAND,IF) = TRU
OR (NAND,FIX) = TRU
OR (NAND,LET) = TRU
OR (NAND,NOR) = NAND
OR (TRU,LEQ) = TRU
OR (TRU,OR) = TRU
OR (TRU,DENY) = TRU
OR (TRU,FLIP) = TRU
OR (TRU,NIF) = TRU
OR (TRU,NTRU) = TRU
OR (TRU,AND) = TRU
OR (TRU,NIMP) = TRU
OR (TRU,XOR) = TRU
OR (TRU,IMP) = TRU
OR (TRU,NAND) = TRU
OR (TRU,TRU) = TRU
OR (TRU,IF) = TRU
OR (TRU,FIX) = TRU
OR (TRU,LET) = TRU
OR (TRU,NOR) = TRU
OR (IF,LEQ) = IF
OR (IF,OR) = TRU
OR (IF,DENY) = IF
OR (IF,FLIP) = TRU
OR (IF,NIF) = TRU
OR (IF,NTRU) = IF
OR (IF,AND) = IF
OR (IF,NIMP) = IF
OR (IF,XOR) = TRU
OR (IF,IMP) = TRU
OR (IF,NAND) = TRU
OR (IF,TRU) = TRU
OR (IF,IF) = IF
OR (IF,FIX) = IF
OR (IF,LET) = TRU
OR (IF,NOR) = IF
OR (FIX,LEQ) = IF
OR (FIX,OR) = OR
OR (FIX,DENY) = IF
OR (FIX,FLIP) = TRU
OR (FIX,NIF) = OR
OR (FIX,NTRU) = FIX
OR (FIX,AND) = FIX
OR (FIX,NIMP) = FIX
OR (FIX,XOR) = OR
OR (FIX,IMP) = TRU
OR (FIX,NAND) = TRU
OR (FIX,TRU) = TRU
OR (FIX,IF) = IF
OR (FIX,FIX) = FIX
OR (FIX,LET) = OR
OR (FIX,NOR) = IF
OR (LET,LEQ) = IMP
OR (LET,OR) = OR
OR (LET,DENY) = TRU
OR (LET,FLIP) = IMP
OR (LET,NIF) = LET
OR (LET,NTRU) = LET
OR (LET,AND) = LET
OR (LET,NIMP) = OR
OR (LET,XOR) = OR
OR (LET,IMP) = IMP
OR (LET,NAND) = TRU
OR (LET,TRU) = TRU
OR (LET,IF) = TRU
OR (LET,FIX) = OR
OR (LET,LET) = LET
OR (LET,NOR) = IMP
OR (NOR,LEQ) = LEQ
OR (NOR,OR) = TRU
OR (NOR,DENY) = DENY
OR (NOR,FLIP) = FLIP
OR (NOR,NIF) = FLIP
OR (NOR,NTRU) = NOR
OR (NOR,AND) = LEQ
OR (NOR,NIMP) = DENY
OR (NOR,XOR) = NAND
OR (NOR,IMP) = IMP
OR (NOR,NAND) = NAND
OR (NOR,TRU) = TRU
OR (NOR,IF) = IF
OR (NOR,FIX) = IF
OR (NOR,LET) = IMP
OR (NOR,NOR) = NOR
DENY (LEQ,LEQ) = XOR
DENY (LEQ,OR) = NOR
DENY (LEQ,DENY) = LET
DENY (LEQ,FLIP) = FIX
DENY (LEQ,NIF) = IF
DENY (LEQ,NTRU) = TRU
DENY (LEQ,AND) = NAND
DENY (LEQ,NIMP) = IMP
DENY (LEQ,XOR) = LEQ
DENY (LEQ,IMP) = NIMP
DENY (LEQ,NAND) = AND
DENY (LEQ,TRU) = NTRU
DENY (LEQ,IF) = NIF
DENY (LEQ,FIX) = FLIP
DENY (LEQ,LET) = DENY
DENY (LEQ,NOR) = OR
DENY (OR,LEQ) = XOR
DENY (OR,OR) = NOR
DENY (OR,DENY) = LET
DENY (OR,FLIP) = FIX
DENY (OR,NIF) = IF
DENY (OR,NTRU) = TRU
DENY (OR,AND) = NAND
DENY (OR,NIMP) = IMP
DENY (OR,XOR) = LEQ
DENY (OR,IMP) = NIMP
DENY (OR,NAND) = AND
DENY (OR,TRU) = NTRU
DENY (OR,IF) = NIF
DENY (OR,FIX) = FLIP
DENY (OR,LET) = DENY
DENY (OR,NOR) = OR
DENY (DENY,LEQ) = XOR
DENY (DENY,OR) = NOR
DENY (DENY,DENY) = LET
DENY (DENY,FLIP) = FIX
DENY (DENY,NIF) = IF
DENY (DENY,NTRU) = TRU
DENY (DENY,AND) = NAND
DENY (DENY,NIMP) = IMP
DENY (DENY,XOR) = LEQ
DENY (DENY,IMP) = NIMP
DENY (DENY,NAND) = AND
DENY (DENY,TRU) = NTRU
DENY (DENY,IF) = NIF
DENY (DENY,FIX) = FLIP
DENY (DENY,LET) = DENY
DENY (DENY,NOR) = OR
DENY (FLIP,LEQ) = XOR
DENY (FLIP,OR) = NOR
DENY (FLIP,DENY) = LET
DENY (FLIP,FLIP) = FIX
DENY (FLIP,NIF) = IF
DENY (FLIP,NTRU) = TRU
DENY (FLIP,AND) = NAND
DENY (FLIP,NIMP) = IMP
DENY (FLIP,XOR) = LEQ
DENY (FLIP,IMP) = NIMP
DENY (FLIP,NAND) = AND
DENY (FLIP,TRU) = NTRU
DENY (FLIP,IF) = NIF
DENY (FLIP,FIX) = FLIP
DENY (FLIP,LET) = DENY
DENY (FLIP,NOR) = OR
DENY (NIF,LEQ) = XOR
DENY (NIF,OR) = NOR
DENY (NIF,DENY) = LET
DENY (NIF,FLIP) = FIX
DENY (NIF,NIF) = IF
DENY (NIF,NTRU) = TRU
DENY (NIF,AND) = NAND
DENY (NIF,NIMP) = IMP
DENY (NIF,XOR) = LEQ
DENY (NIF,IMP) = NIMP
DENY (NIF,NAND) = AND
DENY (NIF,TRU) = NTRU
DENY (NIF,IF) = NIF
DENY (NIF,FIX) = FLIP
DENY (NIF,LET) = DENY
DENY (NIF,NOR) = OR
DENY (NTRU,LEQ) = XOR
DENY (NTRU,OR) = NOR
DENY (NTRU,DENY) = LET
DENY (NTRU,FLIP) = FIX
DENY (NTRU,NIF) = IF
DENY (NTRU,NTRU) = TRU
DENY (NTRU,AND) = NAND
DENY (NTRU,NIMP) = IMP
DENY (NTRU,XOR) = LEQ
DENY (NTRU,IMP) = NIMP
DENY (NTRU,NAND) = AND
DENY (NTRU,TRU) = NTRU
DENY (NTRU,IF) = NIF
DENY (NTRU,FIX) = FLIP
DENY (NTRU,LET) = DENY
DENY (NTRU,NOR) = OR
DENY (AND,LEQ) = XOR
DENY (AND,OR) = NOR
DENY (AND,DENY) = LET
DENY (AND,FLIP) = FIX
DENY (AND,NIF) = IF
DENY (AND,NTRU) = TRU
DENY (AND,AND) = NAND
DENY (AND,NIMP) = IMP
DENY (AND,XOR) = LEQ
DENY (AND,IMP) = NIMP
DENY (AND,NAND) = AND
DENY (AND,TRU) = NTRU
DENY (AND,IF) = NIF
DENY (AND,FIX) = FLIP
DENY (AND,LET) = DENY
DENY (AND,NOR) = OR
DENY (NIMP,LEQ) = XOR
DENY (NIMP,OR) = NOR
DENY (NIMP,DENY) = LET
DENY (NIMP,FLIP) = FIX
DENY (NIMP,NIF) = IF
DENY (NIMP,NTRU) = TRU
DENY (NIMP,AND) = NAND
DENY (NIMP,NIMP) = IMP
DENY (NIMP,XOR) = LEQ
DENY (NIMP,IMP) = NIMP
DENY (NIMP,NAND) = AND
DENY (NIMP,TRU) = NTRU
DENY (NIMP,IF) = NIF
DENY (NIMP,FIX) = FLIP
DENY (NIMP,LET) = DENY
DENY (NIMP,NOR) = OR
DENY (XOR,LEQ) = XOR
DENY (XOR,OR) = NOR
DENY (XOR,DENY) = LET
DENY (XOR,FLIP) = FIX
DENY (XOR,NIF) = IF
DENY (XOR,NTRU) = TRU
DENY (XOR,AND) = NAND
DENY (XOR,NIMP) = IMP
DENY (XOR,XOR) = LEQ
DENY (XOR,IMP) = NIMP
DENY (XOR,NAND) = AND
DENY (XOR,TRU) = NTRU
DENY (XOR,IF) = NIF
DENY (XOR,FIX) = FLIP
DENY (XOR,LET) = DENY
DENY (XOR,NOR) = OR
DENY (IMP,LEQ) = XOR
DENY (IMP,OR) = NOR
DENY (IMP,DENY) = LET
DENY (IMP,FLIP) = FIX
DENY (IMP,NIF) = IF
DENY (IMP,NTRU) = TRU
DENY (IMP,AND) = NAND
DENY (IMP,NIMP) = IMP
DENY (IMP,XOR) = LEQ
DENY (IMP,IMP) = NIMP
DENY (IMP,NAND) = AND
DENY (IMP,TRU) = NTRU
DENY (IMP,IF) = NIF
DENY (IMP,FIX) = FLIP
DENY (IMP,LET) = DENY
DENY (IMP,NOR) = OR
DENY (NAND,LEQ) = XOR
DENY (NAND,OR) = NOR
DENY (NAND,DENY) = LET
DENY (NAND,FLIP) = FIX
DENY (NAND,NIF) = IF
DENY (NAND,NTRU) = TRU
DENY (NAND,AND) = NAND
DENY (NAND,NIMP) = IMP
DENY (NAND,XOR) = LEQ
DENY (NAND,IMP) = NIMP
DENY (NAND,NAND) = AND
DENY (NAND,TRU) = NTRU
DENY (NAND,IF) = NIF
DENY (NAND,FIX) = FLIP
DENY (NAND,LET) = DENY
DENY (NAND,NOR) = OR
DENY (TRU,LEQ) = XOR
DENY (TRU,OR) = NOR
DENY (TRU,DENY) = LET
DENY (TRU,FLIP) = FIX
DENY (TRU,NIF) = IF
DENY (TRU,NTRU) = TRU
DENY (TRU,AND) = NAND
DENY (TRU,NIMP) = IMP
DENY (TRU,XOR) = LEQ
DENY (TRU,IMP) = NIMP
DENY (TRU,NAND) = AND
DENY (TRU,TRU) = NTRU
DENY (TRU,IF) = NIF
DENY (TRU,FIX) = FLIP
DENY (TRU,LET) = DENY
DENY (TRU,NOR) = OR
DENY (IF,LEQ) = XOR
DENY (IF,OR) = NOR
DENY (IF,DENY) = LET
DENY (IF,FLIP) = FIX
DENY (IF,NIF) = IF
DENY (IF,NTRU) = TRU
DENY (IF,AND) = NAND
DENY (IF,NIMP) = IMP
DENY (IF,XOR) = LEQ
DENY (IF,IMP) = NIMP
DENY (IF,NAND) = AND
DENY (IF,TRU) = NTRU
DENY (IF,IF) = NIF
DENY (IF,FIX) = FLIP
DENY (IF,LET) = DENY
DENY (IF,NOR) = OR
DENY (FIX,LEQ) = XOR
DENY (FIX,OR) = NOR
DENY (FIX,DENY) = LET
DENY (FIX,FLIP) = FIX
DENY (FIX,NIF) = IF
DENY (FIX,NTRU) = TRU
DENY (FIX,AND) = NAND
DENY (FIX,NIMP) = IMP
DENY (FIX,XOR) = LEQ
DENY (FIX,IMP) = NIMP
DENY (FIX,NAND) = AND
DENY (FIX,TRU) = NTRU
DENY (FIX,IF) = NIF
DENY (FIX,FIX) = FLIP
DENY (FIX,LET) = DENY
DENY (FIX,NOR) = OR
DENY (LET,LEQ) = XOR
DENY (LET,OR) = NOR
DENY (LET,DENY) = LET
DENY (LET,FLIP) = FIX
DENY (LET,NIF) = IF
DENY (LET,NTRU) = TRU
DENY (LET,AND) = NAND
DENY (LET,NIMP) = IMP
DENY (LET,XOR) = LEQ
DENY (LET,IMP) = NIMP
DENY (LET,NAND) = AND
DENY (LET,TRU) = NTRU
DENY (LET,IF) = NIF
DENY (LET,FIX) = FLIP
DENY (LET,LET) = DENY
DENY (LET,NOR) = OR
DENY (NOR,LEQ) = XOR
DENY (NOR,OR) = NOR
DENY (NOR,DENY) = LET
DENY (NOR,FLIP) = FIX
DENY (NOR,NIF) = IF
DENY (NOR,NTRU) = TRU
DENY (NOR,AND) = NAND
DENY (NOR,NIMP) = IMP
DENY (NOR,XOR) = LEQ
DENY (NOR,IMP) = NIMP
DENY (NOR,NAND) = AND
DENY (NOR,TRU) = NTRU
DENY (NOR,IF) = NIF
DENY (NOR,FIX) = FLIP
DENY (NOR,LET) = DENY
DENY (NOR,NOR) = OR
FLIP (LEQ,LEQ) = XOR
FLIP (LEQ,OR) = XOR
FLIP (LEQ,DENY) = XOR
FLIP (LEQ,FLIP) = XOR
FLIP (LEQ,NIF) = XOR
FLIP (LEQ,NTRU) = XOR
FLIP (LEQ,AND) = XOR
FLIP (LEQ,NIMP) = XOR
FLIP (LEQ,XOR) = XOR
FLIP (LEQ,IMP) = XOR
FLIP (LEQ,NAND) = XOR
FLIP (LEQ,TRU) = XOR
FLIP (LEQ,IF) = XOR
FLIP (LEQ,FIX) = XOR
FLIP (LEQ,LET) = XOR
FLIP (LEQ,NOR) = XOR
FLIP (OR,LEQ) = NOR
FLIP (OR,OR) = NOR
FLIP (OR,DENY) = NOR
FLIP (OR,FLIP) = NOR
FLIP (OR,NIF) = NOR
FLIP (OR,NTRU) = NOR
FLIP (OR,AND) = NOR
FLIP (OR,NIMP) = NOR
FLIP (OR,XOR) = NOR
FLIP (OR,IMP) = NOR
FLIP (OR,NAND) = NOR
FLIP (OR,TRU) = NOR
FLIP (OR,IF) = NOR
FLIP (OR,FIX) = NOR
FLIP (OR,LET) = NOR
FLIP (OR,NOR) = NOR
FLIP (DENY,LEQ) = LET
FLIP (DENY,OR) = LET
FLIP (DENY,DENY) = LET
FLIP (DENY,FLIP) = LET
FLIP (DENY,NIF) = LET
FLIP (DENY,NTRU) = LET
FLIP (DENY,AND) = LET
FLIP (DENY,NIMP) = LET
FLIP (DENY,XOR) = LET
FLIP (DENY,IMP) = LET
FLIP (DENY,NAND) = LET
FLIP (DENY,TRU) = LET
FLIP (DENY,IF) = LET
FLIP (DENY,FIX) = LET
FLIP (DENY,LET) = LET
FLIP (DENY,NOR) = LET
FLIP (FLIP,LEQ) = FIX
FLIP (FLIP,OR) = FIX
FLIP (FLIP,DENY) = FIX
FLIP (FLIP,FLIP) = FIX
FLIP (FLIP,NIF) = FIX
FLIP (FLIP,NTRU) = FIX
FLIP (FLIP,AND) = FIX
FLIP (FLIP,NIMP) = FIX
FLIP (FLIP,XOR) = FIX
FLIP (FLIP,IMP) = FIX
FLIP (FLIP,NAND) = FIX
FLIP (FLIP,TRU) = FIX
FLIP (FLIP,IF) = FIX
FLIP (FLIP,FIX) = FIX
FLIP (FLIP,LET) = FIX
FLIP (FLIP,NOR) = FIX
FLIP (NIF,LEQ) = IF
FLIP (NIF,OR) = IF
FLIP (NIF,DENY) = IF
FLIP (NIF,FLIP) = IF
FLIP (NIF,NIF) = IF
FLIP (NIF,NTRU) = IF
FLIP (NIF,AND) = IF
FLIP (NIF,NIMP) = IF
FLIP (NIF,XOR) = IF
FLIP (NIF,IMP) = IF
FLIP (NIF,NAND) = IF
FLIP (NIF,TRU) = IF
FLIP (NIF,IF) = IF
FLIP (NIF,FIX) = IF
FLIP (NIF,LET) = IF
FLIP (NIF,NOR) = IF
FLIP (NTRU,LEQ) = TRU
FLIP (NTRU,OR) = TRU
FLIP (NTRU,DENY) = TRU
FLIP (NTRU,FLIP) = TRU
FLIP (NTRU,NIF) = TRU
FLIP (NTRU,NTRU) = TRU
FLIP (NTRU,AND) = TRU
FLIP (NTRU,NIMP) = TRU
FLIP (NTRU,XOR) = TRU
FLIP (NTRU,IMP) = TRU
FLIP (NTRU,NAND) = TRU
FLIP (NTRU,TRU) = TRU
FLIP (NTRU,IF) = TRU
FLIP (NTRU,FIX) = TRU
FLIP (NTRU,LET) = TRU
FLIP (NTRU,NOR) = TRU
FLIP (AND,LEQ) = NAND
FLIP (AND,OR) = NAND
FLIP (AND,DENY) = NAND
FLIP (AND,FLIP) = NAND
FLIP (AND,NIF) = NAND
FLIP (AND,NTRU) = NAND
FLIP (AND,AND) = NAND
FLIP (AND,NIMP) = NAND
FLIP (AND,XOR) = NAND
FLIP (AND,IMP) = NAND
FLIP (AND,NAND) = NAND
FLIP (AND,TRU) = NAND
FLIP (AND,IF) = NAND
FLIP (AND,FIX) = NAND
FLIP (AND,LET) = NAND
FLIP (AND,NOR) = NAND
FLIP (NIMP,LEQ) = IMP
FLIP (NIMP,OR) = IMP
FLIP (NIMP,DENY) = IMP
FLIP (NIMP,FLIP) = IMP
FLIP (NIMP,NIF) = IMP
FLIP (NIMP,NTRU) = IMP
FLIP (NIMP,AND) = IMP
FLIP (NIMP,NIMP) = IMP
FLIP (NIMP,XOR) = IMP
FLIP (NIMP,IMP) = IMP
FLIP (NIMP,NAND) = IMP
FLIP (NIMP,TRU) = IMP
FLIP (NIMP,IF) = IMP
FLIP (NIMP,FIX) = IMP
FLIP (NIMP,LET) = IMP
FLIP (NIMP,NOR) = IMP
FLIP (XOR,LEQ) = LEQ
FLIP (XOR,OR) = LEQ
FLIP (XOR,DENY) = LEQ
FLIP (XOR,FLIP) = LEQ
FLIP (XOR,NIF) = LEQ
FLIP (XOR,NTRU) = LEQ
FLIP (XOR,AND) = LEQ
FLIP (XOR,NIMP) = LEQ
FLIP (XOR,XOR) = LEQ
FLIP (XOR,IMP) = LEQ
FLIP (XOR,NAND) = LEQ
FLIP (XOR,TRU) = LEQ
FLIP (XOR,IF) = LEQ
FLIP (XOR,FIX) = LEQ
FLIP (XOR,LET) = LEQ
FLIP (XOR,NOR) = LEQ
FLIP (IMP,LEQ) = NIMP
FLIP (IMP,OR) = NIMP
FLIP (IMP,DENY) = NIMP
FLIP (IMP,FLIP) = NIMP
FLIP (IMP,NIF) = NIMP
FLIP (IMP,NTRU) = NIMP
FLIP (IMP,AND) = NIMP
FLIP (IMP,NIMP) = NIMP
FLIP (IMP,XOR) = NIMP
FLIP (IMP,IMP) = NIMP
FLIP (IMP,NAND) = NIMP
FLIP (IMP,TRU) = NIMP
FLIP (IMP,IF) = NIMP
FLIP (IMP,FIX) = NIMP
FLIP (IMP,LET) = NIMP
FLIP (IMP,NOR) = NIMP
FLIP (NAND,LEQ) = AND
FLIP (NAND,OR) = AND
FLIP (NAND,DENY) = AND
FLIP (NAND,FLIP) = AND
FLIP (NAND,NIF) = AND
FLIP (NAND,NTRU) = AND
FLIP (NAND,AND) = AND
FLIP (NAND,NIMP) = AND
FLIP (NAND,XOR) = AND
FLIP (NAND,IMP) = AND
FLIP (NAND,NAND) = AND
FLIP (NAND,TRU) = AND
FLIP (NAND,IF) = AND
FLIP (NAND,FIX) = AND
FLIP (NAND,LET) = AND
FLIP (NAND,NOR) = AND
FLIP (TRU,LEQ) = NTRU
FLIP (TRU,OR) = NTRU
FLIP (TRU,DENY) = NTRU
FLIP (TRU,FLIP) = NTRU
FLIP (TRU,NIF) = NTRU
FLIP (TRU,NTRU) = NTRU
FLIP (TRU,AND) = NTRU
FLIP (TRU,NIMP) = NTRU
FLIP (TRU,XOR) = NTRU
FLIP (TRU,IMP) = NTRU
FLIP (TRU,NAND) = NTRU
FLIP (TRU,TRU) = NTRU
FLIP (TRU,IF) = NTRU
FLIP (TRU,FIX) = NTRU
FLIP (TRU,LET) = NTRU
FLIP (TRU,NOR) = NTRU
FLIP (IF,LEQ) = NIF
FLIP (IF,OR) = NIF
FLIP (IF,DENY) = NIF
FLIP (IF,FLIP) = NIF
FLIP (IF,NIF) = NIF
FLIP (IF,NTRU) = NIF
FLIP (IF,AND) = NIF
FLIP (IF,NIMP) = NIF
FLIP (IF,XOR) = NIF
FLIP (IF,IMP) = NIF
FLIP (IF,NAND) = NIF
FLIP (IF,TRU) = NIF
FLIP (IF,IF) = NIF
FLIP (IF,FIX) = NIF
FLIP (IF,LET) = NIF
FLIP (IF,NOR) = NIF
FLIP (FIX,LEQ) = FLIP
FLIP (FIX,OR) = FLIP
FLIP (FIX,DENY) = FLIP
FLIP (FIX,FLIP) = FLIP
FLIP (FIX,NIF) = FLIP
FLIP (FIX,NTRU) = FLIP
FLIP (FIX,AND) = FLIP
FLIP (FIX,NIMP) = FLIP
FLIP (FIX,XOR) = FLIP
FLIP (FIX,IMP) = FLIP
FLIP (FIX,NAND) = FLIP
FLIP (FIX,TRU) = FLIP
FLIP (FIX,IF) = FLIP
FLIP (FIX,FIX) = FLIP
FLIP (FIX,LET) = FLIP
FLIP (FIX,NOR) = FLIP
FLIP (LET,LEQ) = DENY
FLIP (LET,OR) = DENY
FLIP (LET,DENY) = DENY
FLIP (LET,FLIP) = DENY
FLIP (LET,NIF) = DENY
FLIP (LET,NTRU) = DENY
FLIP (LET,AND) = DENY
FLIP (LET,NIMP) = DENY
FLIP (LET,XOR) = DENY
FLIP (LET,IMP) = DENY
FLIP (LET,NAND) = DENY
FLIP (LET,TRU) = DENY
FLIP (LET,IF) = DENY
FLIP (LET,FIX) = DENY
FLIP (LET,LET) = DENY
FLIP (LET,NOR) = DENY
FLIP (NOR,LEQ) = OR
FLIP (NOR,OR) = OR
FLIP (NOR,DENY) = OR
FLIP (NOR,FLIP) = OR
FLIP (NOR,NIF) = OR
FLIP (NOR,NTRU) = OR
FLIP (NOR,AND) = OR
FLIP (NOR,NIMP) = OR
FLIP (NOR,XOR) = OR
FLIP (NOR,IMP) = OR
FLIP (NOR,NAND) = OR
FLIP (NOR,TRU) = OR
FLIP (NOR,IF) = OR
FLIP (NOR,FIX) = OR
FLIP (NOR,LET) = OR
FLIP (NOR,NOR) = OR
NIF (LEQ,LEQ) = NTRU
NIF (LEQ,OR) = XOR
NIF (LEQ,DENY) = NIMP
NIF (LEQ,FLIP) = NIF
NIF (LEQ,NIF) = NIF
NIF (LEQ,NTRU) = NTRU
NIF (LEQ,AND) = NTRU
NIF (LEQ,NIMP) = NIMP
NIF (LEQ,XOR) = XOR
NIF (LEQ,IMP) = NIF
NIF (LEQ,NAND) = XOR
NIF (LEQ,TRU) = XOR
NIF (LEQ,IF) = NIMP
NIF (LEQ,FIX) = NIMP
NIF (LEQ,LET) = NIF
NIF (LEQ,NOR) = NTRU
NIF (OR,LEQ) = NOR
NIF (OR,OR) = NTRU
NIF (OR,DENY) = NOR
NIF (OR,FLIP) = NOR
NIF (OR,NIF) = NTRU
NIF (OR,NTRU) = NTRU
NIF (OR,AND) = NTRU
NIF (OR,NIMP) = NTRU
NIF (OR,XOR) = NTRU
NIF (OR,IMP) = NOR
NIF (OR,NAND) = NOR
NIF (OR,TRU) = NOR
NIF (OR,IF) = NOR
NIF (OR,FIX) = NTRU
NIF (OR,LET) = NTRU
NIF (OR,NOR) = NOR
NIF (DENY,LEQ) = AND
NIF (DENY,OR) = LET
NIF (DENY,DENY) = NTRU
NIF (DENY,FLIP) = NIF
NIF (DENY,NIF) = NIF
NIF (DENY,NTRU) = NTRU
NIF (DENY,AND) = AND
NIF (DENY,NIMP) = NTRU
NIF (DENY,XOR) = NIF
NIF (DENY,IMP) = LET
NIF (DENY,NAND) = NIF
NIF (DENY,TRU) = LET
NIF (DENY,IF) = AND
NIF (DENY,FIX) = AND
NIF (DENY,LET) = LET
NIF (DENY,NOR) = NTRU
NIF (FLIP,LEQ) = AND
NIF (FLIP,OR) = FIX
NIF (FLIP,DENY) = NIMP
NIF (FLIP,FLIP) = NTRU
NIF (FLIP,NIF) = NTRU
NIF (FLIP,NTRU) = NTRU
NIF (FLIP,AND) = AND
NIF (FLIP,NIMP) = NIMP
NIF (FLIP,XOR) = NIMP
NIF (FLIP,IMP) = AND
NIF (FLIP,NAND) = NIMP
NIF (FLIP,TRU) = FIX
NIF (FLIP,IF) = FIX
NIF (FLIP,FIX) = FIX
NIF (FLIP,LET) = AND
NIF (FLIP,NOR) = NTRU
NIF (NIF,LEQ) = LEQ
NIF (NIF,OR) = FIX
NIF (NIF,DENY) = DENY
NIF (NIF,FLIP) = NOR
NIF (NIF,NIF) = NTRU
NIF (NIF,NTRU) = NTRU
NIF (NIF,AND) = AND
NIF (NIF,NIMP) = NIMP
NIF (NIF,XOR) = NIMP
NIF (NIF,IMP) = LEQ
NIF (NIF,NAND) = DENY
NIF (NIF,TRU) = IF
NIF (NIF,IF) = IF
NIF (NIF,FIX) = FIX
NIF (NIF,LET) = AND
NIF (NIF,NOR) = NOR
NIF (NTRU,LEQ) = LEQ
NIF (NTRU,OR) = OR
NIF (NTRU,DENY) = DENY
NIF (NTRU,FLIP) = FLIP
NIF (NTRU,NIF) = NIF
NIF (NTRU,NTRU) = NTRU
NIF (NTRU,AND) = AND
NIF (NTRU,NIMP) = NIMP
NIF (NTRU,XOR) = XOR
NIF (NTRU,IMP) = IMP
NIF (NTRU,NAND) = NAND
NIF (NTRU,TRU) = TRU
NIF (NTRU,IF) = IF
NIF (NTRU,FIX) = FIX
NIF (NTRU,LET) = LET
NIF (NTRU,NOR) = NOR
NIF (AND,LEQ) = NOR
NIF (AND,OR) = XOR
NIF (AND,DENY) = DENY
NIF (AND,FLIP) = FLIP
NIF (AND,NIF) = NIF
NIF (AND,NTRU) = NTRU
NIF (AND,AND) = NTRU
NIF (AND,NIMP) = NIMP
NIF (AND,XOR) = XOR
NIF (AND,IMP) = FLIP
NIF (AND,NAND) = NAND
NIF (AND,TRU) = NAND
NIF (AND,IF) = DENY
NIF (AND,FIX) = NIMP
NIF (AND,LET) = NIF
NIF (AND,NOR) = NOR
NIF (NIMP,LEQ) = LEQ
NIF (NIMP,OR) = LET
NIF (NIMP,DENY) = NOR
NIF (NIMP,FLIP) = FLIP
NIF (NIMP,NIF) = NIF
NIF (NIMP,NTRU) = NTRU
NIF (NIMP,AND) = AND
NIF (NIMP,NIMP) = NTRU
NIF (NIMP,XOR) = NIF
NIF (NIMP,IMP) = IMP
NIF (NIMP,NAND) = FLIP
NIF (NIMP,TRU) = IMP
NIF (NIMP,IF) = LEQ
NIF (NIMP,FIX) = AND
NIF (NIMP,LET) = LET
NIF (NIMP,NOR) = NOR
NIF (XOR,LEQ) = LEQ
NIF (XOR,OR) = AND
NIF (XOR,DENY) = NOR
NIF (XOR,FLIP) = NOR
NIF (XOR,NIF) = NTRU
NIF (XOR,NTRU) = NTRU
NIF (XOR,AND) = AND
NIF (XOR,NIMP) = NTRU
NIF (XOR,XOR) = NTRU
NIF (XOR,IMP) = LEQ
NIF (XOR,NAND) = NOR
NIF (XOR,TRU) = LEQ
NIF (XOR,IF) = LEQ
NIF (XOR,FIX) = AND
NIF (XOR,LET) = AND
NIF (XOR,NOR) = NOR
NIF (IMP,LEQ) = NTRU
NIF (IMP,OR) = NIMP
NIF (IMP,DENY) = NIMP
NIF (IMP,FLIP) = NTRU
NIF (IMP,NIF) = NTRU
NIF (IMP,NTRU) = NTRU
NIF (IMP,AND) = NTRU
NIF (IMP,NIMP) = NIMP
NIF (IMP,XOR) = NIMP
NIF (IMP,IMP) = NTRU
NIF (IMP,NAND) = NIMP
NIF (IMP,TRU) = NIMP
NIF (IMP,IF) = NIMP
NIF (IMP,FIX) = NIMP
NIF (IMP,LET) = NTRU
NIF (IMP,NOR) = NTRU
NIF (NAND,LEQ) = AND
NIF (NAND,OR) = AND
NIF (NAND,DENY) = NTRU
NIF (NAND,FLIP) = NTRU
NIF (NAND,NIF) = NTRU
NIF (NAND,NTRU) = NTRU
NIF (NAND,AND) = AND
NIF (NAND,NIMP) = NTRU
NIF (NAND,XOR) = NTRU
NIF (NAND,IMP) = AND
NIF (NAND,NAND) = NTRU
NIF (NAND,TRU) = AND
NIF (NAND,IF) = AND
NIF (NAND,FIX) = AND
NIF (NAND,LET) = AND
NIF (NAND,NOR) = NTRU
NIF (TRU,LEQ) = NTRU
NIF (TRU,OR) = NTRU
NIF (TRU,DENY) = NTRU
NIF (TRU,FLIP) = NTRU
NIF (TRU,NIF) = NTRU
NIF (TRU,NTRU) = NTRU
NIF (TRU,AND) = NTRU
NIF (TRU,NIMP) = NTRU
NIF (TRU,XOR) = NTRU
NIF (TRU,IMP) = NTRU
NIF (TRU,NAND) = NTRU
NIF (TRU,TRU) = NTRU
NIF (TRU,IF) = NTRU
NIF (TRU,FIX) = NTRU
NIF (TRU,LET) = NTRU
NIF (TRU,NOR) = NTRU
NIF (IF,LEQ) = NTRU
NIF (IF,OR) = NIF
NIF (IF,DENY) = NTRU
NIF (IF,FLIP) = NIF
NIF (IF,NIF) = NIF
NIF (IF,NTRU) = NTRU
NIF (IF,AND) = NTRU
NIF (IF,NIMP) = NTRU
NIF (IF,XOR) = NIF
NIF (IF,IMP) = NIF
NIF (IF,NAND) = NIF
NIF (IF,TRU) = NIF
NIF (IF,IF) = NTRU
NIF (IF,FIX) = NTRU
NIF (IF,LET) = NIF
NIF (IF,NOR) = NTRU
NIF (FIX,LEQ) = NOR
NIF (FIX,OR) = NIF
NIF (FIX,DENY) = NOR
NIF (FIX,FLIP) = FLIP
NIF (FIX,NIF) = NIF
NIF (FIX,NTRU) = NTRU
NIF (FIX,AND) = NTRU
NIF (FIX,NIMP) = NTRU
NIF (FIX,XOR) = NIF
NIF (FIX,IMP) = FLIP
NIF (FIX,NAND) = FLIP
NIF (FIX,TRU) = FLIP
NIF (FIX,IF) = NOR
NIF (FIX,FIX) = NTRU
NIF (FIX,LET) = NIF
NIF (FIX,NOR) = NOR
NIF (LET,LEQ) = NOR
NIF (LET,OR) = NIMP
NIF (LET,DENY) = DENY
NIF (LET,FLIP) = NOR
NIF (LET,NIF) = NTRU
NIF (LET,NTRU) = NTRU
NIF (LET,AND) = NTRU
NIF (LET,NIMP) = NIMP
NIF (LET,XOR) = NIMP
NIF (LET,IMP) = NOR
NIF (LET,NAND) = DENY
NIF (LET,TRU) = DENY
NIF (LET,IF) = DENY
NIF (LET,FIX) = NIMP
NIF (LET,LET) = NTRU
NIF (LET,NOR) = NOR
NIF (NOR,LEQ) = AND
NIF (NOR,OR) = OR
NIF (NOR,DENY) = NIMP
NIF (NOR,FLIP) = NIF
NIF (NOR,NIF) = NIF
NIF (NOR,NTRU) = NTRU
NIF (NOR,AND) = AND
NIF (NOR,NIMP) = NIMP
NIF (NOR,XOR) = XOR
NIF (NOR,IMP) = LET
NIF (NOR,NAND) = XOR
NIF (NOR,TRU) = OR
NIF (NOR,IF) = FIX
NIF (NOR,FIX) = FIX
NIF (NOR,LET) = LET
NIF (NOR,NOR) = NTRU
NTRU (LEQ,LEQ) = NTRU
NTRU (LEQ,OR) = NTRU
NTRU (LEQ,DENY) = NTRU
NTRU (LEQ,FLIP) = NTRU
NTRU (LEQ,NIF) = NTRU
NTRU (LEQ,NTRU) = NTRU
NTRU (LEQ,AND) = NTRU
NTRU (LEQ,NIMP) = NTRU
NTRU (LEQ,XOR) = NTRU
NTRU (LEQ,IMP) = NTRU
NTRU (LEQ,NAND) = NTRU
NTRU (LEQ,TRU) = NTRU
NTRU (LEQ,IF) = NTRU
NTRU (LEQ,FIX) = NTRU
NTRU (LEQ,LET) = NTRU
NTRU (LEQ,NOR) = NTRU
NTRU (OR,LEQ) = NTRU
NTRU (OR,OR) = NTRU
NTRU (OR,DENY) = NTRU
NTRU (OR,FLIP) = NTRU
NTRU (OR,NIF) = NTRU
NTRU (OR,NTRU) = NTRU
NTRU (OR,AND) = NTRU
NTRU (OR,NIMP) = NTRU
NTRU (OR,XOR) = NTRU
NTRU (OR,IMP) = NTRU
NTRU (OR,NAND) = NTRU
NTRU (OR,TRU) = NTRU
NTRU (OR,IF) = NTRU
NTRU (OR,FIX) = NTRU
NTRU (OR,LET) = NTRU
NTRU (OR,NOR) = NTRU
NTRU (DENY,LEQ) = NTRU
NTRU (DENY,OR) = NTRU
NTRU (DENY,DENY) = NTRU
NTRU (DENY,FLIP) = NTRU
NTRU (DENY,NIF) = NTRU
NTRU (DENY,NTRU) = NTRU
NTRU (DENY,AND) = NTRU
NTRU (DENY,NIMP) = NTRU
NTRU (DENY,XOR) = NTRU
NTRU (DENY,IMP) = NTRU
NTRU (DENY,NAND) = NTRU
NTRU (DENY,TRU) = NTRU
NTRU (DENY,IF) = NTRU
NTRU (DENY,FIX) = NTRU
NTRU (DENY,LET) = NTRU
NTRU (DENY,NOR) = NTRU
NTRU (FLIP,LEQ) = NTRU
NTRU (FLIP,OR) = NTRU
NTRU (FLIP,DENY) = NTRU
NTRU (FLIP,FLIP) = NTRU
NTRU (FLIP,NIF) = NTRU
NTRU (FLIP,NTRU) = NTRU
NTRU (FLIP,AND) = NTRU
NTRU (FLIP,NIMP) = NTRU
NTRU (FLIP,XOR) = NTRU
NTRU (FLIP,IMP) = NTRU
NTRU (FLIP,NAND) = NTRU
NTRU (FLIP,TRU) = NTRU
NTRU (FLIP,IF) = NTRU
NTRU (FLIP,FIX) = NTRU
NTRU (FLIP,LET) = NTRU
NTRU (FLIP,NOR) = NTRU
NTRU (NIF,LEQ) = NTRU
NTRU (NIF,OR) = NTRU
NTRU (NIF,DENY) = NTRU
NTRU (NIF,FLIP) = NTRU
NTRU (NIF,NIF) = NTRU
NTRU (NIF,NTRU) = NTRU
NTRU (NIF,AND) = NTRU
NTRU (NIF,NIMP) = NTRU
NTRU (NIF,XOR) = NTRU
NTRU (NIF,IMP) = NTRU
NTRU (NIF,NAND) = NTRU
NTRU (NIF,TRU) = NTRU
NTRU (NIF,IF) = NTRU
NTRU (NIF,FIX) = NTRU
NTRU (NIF,LET) = NTRU
NTRU (NIF,NOR) = NTRU
NTRU (NTRU,LEQ) = NTRU
NTRU (NTRU,OR) = NTRU
NTRU (NTRU,DENY) = NTRU
NTRU (NTRU,FLIP) = NTRU
NTRU (NTRU,NIF) = NTRU
NTRU (NTRU,NTRU) = NTRU
NTRU (NTRU,AND) = NTRU
NTRU (NTRU,NIMP) = NTRU
NTRU (NTRU,XOR) = NTRU
NTRU (NTRU,IMP) = NTRU
NTRU (NTRU,NAND) = NTRU
NTRU (NTRU,TRU) = NTRU
NTRU (NTRU,IF) = NTRU
NTRU (NTRU,FIX) = NTRU
NTRU (NTRU,LET) = NTRU
NTRU (NTRU,NOR) = NTRU
NTRU (AND,LEQ) = NTRU
NTRU (AND,OR) = NTRU
NTRU (AND,DENY) = NTRU
NTRU (AND,FLIP) = NTRU
NTRU (AND,NIF) = NTRU
NTRU (AND,NTRU) = NTRU
NTRU (AND,AND) = NTRU
NTRU (AND,NIMP) = NTRU
NTRU (AND,XOR) = NTRU
NTRU (AND,IMP) = NTRU
NTRU (AND,NAND) = NTRU
NTRU (AND,TRU) = NTRU
NTRU (AND,IF) = NTRU
NTRU (AND,FIX) = NTRU
NTRU (AND,LET) = NTRU
NTRU (AND,NOR) = NTRU
NTRU (NIMP,LEQ) = NTRU
NTRU (NIMP,OR) = NTRU
NTRU (NIMP,DENY) = NTRU
NTRU (NIMP,FLIP) = NTRU
NTRU (NIMP,NIF) = NTRU
NTRU (NIMP,NTRU) = NTRU
NTRU (NIMP,AND) = NTRU
NTRU (NIMP,NIMP) = NTRU
NTRU (NIMP,XOR) = NTRU
NTRU (NIMP,IMP) = NTRU
NTRU (NIMP,NAND) = NTRU
NTRU (NIMP,TRU) = NTRU
NTRU (NIMP,IF) = NTRU
NTRU (NIMP,FIX) = NTRU
NTRU (NIMP,LET) = NTRU
NTRU (NIMP,NOR) = NTRU
NTRU (XOR,LEQ) = NTRU
NTRU (XOR,OR) = NTRU
NTRU (XOR,DENY) = NTRU
NTRU (XOR,FLIP) = NTRU
NTRU (XOR,NIF) = NTRU
NTRU (XOR,NTRU) = NTRU
NTRU (XOR,AND) = NTRU
NTRU (XOR,NIMP) = NTRU
NTRU (XOR,XOR) = NTRU
NTRU (XOR,IMP) = NTRU
NTRU (XOR,NAND) = NTRU
NTRU (XOR,TRU) = NTRU
NTRU (XOR,IF) = NTRU
NTRU (XOR,FIX) = NTRU
NTRU (XOR,LET) = NTRU
NTRU (XOR,NOR) = NTRU
NTRU (IMP,LEQ) = NTRU
NTRU (IMP,OR) = NTRU
NTRU (IMP,DENY) = NTRU
NTRU (IMP,FLIP) = NTRU
NTRU (IMP,NIF) = NTRU
NTRU (IMP,NTRU) = NTRU
NTRU (IMP,AND) = NTRU
NTRU (IMP,NIMP) = NTRU
NTRU (IMP,XOR) = NTRU
NTRU (IMP,IMP) = NTRU
NTRU (IMP,NAND) = NTRU
NTRU (IMP,TRU) = NTRU
NTRU (IMP,IF) = NTRU
NTRU (IMP,FIX) = NTRU
NTRU (IMP,LET) = NTRU
NTRU (IMP,NOR) = NTRU
NTRU (NAND,LEQ) = NTRU
NTRU (NAND,OR) = NTRU
NTRU (NAND,DENY) = NTRU
NTRU (NAND,FLIP) = NTRU
NTRU (NAND,NIF) = NTRU
NTRU (NAND,NTRU) = NTRU
NTRU (NAND,AND) = NTRU
NTRU (NAND,NIMP) = NTRU
NTRU (NAND,XOR) = NTRU
NTRU (NAND,IMP) = NTRU
NTRU (NAND,NAND) = NTRU
NTRU (NAND,TRU) = NTRU
NTRU (NAND,IF) = NTRU
NTRU (NAND,FIX) = NTRU
NTRU (NAND,LET) = NTRU
NTRU (NAND,NOR) = NTRU
NTRU (TRU,LEQ) = NTRU
NTRU (TRU,OR) = NTRU
NTRU (TRU,DENY) = NTRU
NTRU (TRU,FLIP) = NTRU
NTRU (TRU,NIF) = NTRU
NTRU (TRU,NTRU) = NTRU
NTRU (TRU,AND) = NTRU
NTRU (TRU,NIMP) = NTRU
NTRU (TRU,XOR) = NTRU
NTRU (TRU,IMP) = NTRU
NTRU (TRU,NAND) = NTRU
NTRU (TRU,TRU) = NTRU
NTRU (TRU,IF) = NTRU
NTRU (TRU,FIX) = NTRU
NTRU (TRU,LET) = NTRU
NTRU (TRU,NOR) = NTRU
NTRU (IF,LEQ) = NTRU
NTRU (IF,OR) = NTRU
NTRU (IF,DENY) = NTRU
NTRU (IF,FLIP) = NTRU
NTRU (IF,NIF) = NTRU
NTRU (IF,NTRU) = NTRU
NTRU (IF,AND) = NTRU
NTRU (IF,NIMP) = NTRU
NTRU (IF,XOR) = NTRU
NTRU (IF,IMP) = NTRU
NTRU (IF,NAND) = NTRU
NTRU (IF,TRU) = NTRU
NTRU (IF,IF) = NTRU
NTRU (IF,FIX) = NTRU
NTRU (IF,LET) = NTRU
NTRU (IF,NOR) = NTRU
NTRU (FIX,LEQ) = NTRU
NTRU (FIX,OR) = NTRU
NTRU (FIX,DENY) = NTRU
NTRU (FIX,FLIP) = NTRU
NTRU (FIX,NIF) = NTRU
NTRU (FIX,NTRU) = NTRU
NTRU (FIX,AND) = NTRU
NTRU (FIX,NIMP) = NTRU
NTRU (FIX,XOR) = NTRU
NTRU (FIX,IMP) = NTRU
NTRU (FIX,NAND) = NTRU
NTRU (FIX,TRU) = NTRU
NTRU (FIX,IF) = NTRU
NTRU (FIX,FIX) = NTRU
NTRU (FIX,LET) = NTRU
NTRU (FIX,NOR) = NTRU
NTRU (LET,LEQ) = NTRU
NTRU (LET,OR) = NTRU
NTRU (LET,DENY) = NTRU
NTRU (LET,FLIP) = NTRU
NTRU (LET,NIF) = NTRU
NTRU (LET,NTRU) = NTRU
NTRU (LET,AND) = NTRU
NTRU (LET,NIMP) = NTRU
NTRU (LET,XOR) = NTRU
NTRU (LET,IMP) = NTRU
NTRU (LET,NAND) = NTRU
NTRU (LET,TRU) = NTRU
NTRU (LET,IF) = NTRU
NTRU (LET,FIX) = NTRU
NTRU (LET,LET) = NTRU
NTRU (LET,NOR) = NTRU
NTRU (NOR,LEQ) = NTRU
NTRU (NOR,OR) = NTRU
NTRU (NOR,DENY) = NTRU
NTRU (NOR,FLIP) = NTRU
NTRU (NOR,NIF) = NTRU
NTRU (NOR,NTRU) = NTRU
NTRU (NOR,AND) = NTRU
NTRU (NOR,NIMP) = NTRU
NTRU (NOR,XOR) = NTRU
NTRU (NOR,IMP) = NTRU
NTRU (NOR,NAND) = NTRU
NTRU (NOR,TRU) = NTRU
NTRU (NOR,IF) = NTRU
NTRU (NOR,FIX) = NTRU
NTRU (NOR,LET) = NTRU
NTRU (NOR,NOR) = NTRU
AND (LEQ,LEQ) = LEQ
AND (LEQ,OR) = AND
AND (LEQ,DENY) = NOR
AND (LEQ,FLIP) = NOR
AND (LEQ,NIF) = NTRU
AND (LEQ,NTRU) = NTRU
AND (LEQ,AND) = AND
AND (LEQ,NIMP) = NTRU
AND (LEQ,XOR) = NTRU
AND (LEQ,IMP) = LEQ
AND (LEQ,NAND) = NOR
AND (LEQ,TRU) = LEQ
AND (LEQ,IF) = LEQ
AND (LEQ,FIX) = AND
AND (LEQ,LET) = AND
AND (LEQ,NOR) = NOR
AND (OR,LEQ) = AND
AND (OR,OR) = OR
AND (OR,DENY) = NIMP
AND (OR,FLIP) = NIF
AND (OR,NIF) = NIF
AND (OR,NTRU) = NTRU
AND (OR,AND) = AND
AND (OR,NIMP) = NIMP
AND (OR,XOR) = XOR
AND (OR,IMP) = LET
AND (OR,NAND) = XOR
AND (OR,TRU) = OR
AND (OR,IF) = FIX
AND (OR,FIX) = FIX
AND (OR,LET) = LET
AND (OR,NOR) = NTRU
AND (DENY,LEQ) = NOR
AND (DENY,OR) = NIMP
AND (DENY,DENY) = DENY
AND (DENY,FLIP) = NOR
AND (DENY,NIF) = NTRU
AND (DENY,NTRU) = NTRU
AND (DENY,AND) = NTRU
AND (DENY,NIMP) = NIMP
AND (DENY,XOR) = NIMP
AND (DENY,IMP) = NOR
AND (DENY,NAND) = DENY
AND (DENY,TRU) = DENY
AND (DENY,IF) = DENY
AND (DENY,FIX) = NIMP
AND (DENY,LET) = NTRU
AND (DENY,NOR) = NOR
AND (FLIP,LEQ) = NOR
AND (FLIP,OR) = NIF
AND (FLIP,DENY) = NOR
AND (FLIP,FLIP) = FLIP
AND (FLIP,NIF) = NIF
AND (FLIP,NTRU) = NTRU
AND (FLIP,AND) = NTRU
AND (FLIP,NIMP) = NTRU
AND (FLIP,XOR) = NIF
AND (FLIP,IMP) = FLIP
AND (FLIP,NAND) = FLIP
AND (FLIP,TRU) = FLIP
AND (FLIP,IF) = NOR
AND (FLIP,FIX) = NTRU
AND (FLIP,LET) = NIF
AND (FLIP,NOR) = NOR
AND (NIF,LEQ) = NTRU
AND (NIF,OR) = NIF
AND (NIF,DENY) = NTRU
AND (NIF,FLIP) = NIF
AND (NIF,NIF) = NIF
AND (NIF,NTRU) = NTRU
AND (NIF,AND) = NTRU
AND (NIF,NIMP) = NTRU
AND (NIF,XOR) = NIF
AND (NIF,IMP) = NIF
AND (NIF,NAND) = NIF
AND (NIF,TRU) = NIF
AND (NIF,IF) = NTRU
AND (NIF,FIX) = NTRU
AND (NIF,LET) = NIF
AND (NIF,NOR) = NTRU
AND (NTRU,LEQ) = NTRU
AND (NTRU,OR) = NTRU
AND (NTRU,DENY) = NTRU
AND (NTRU,FLIP) = NTRU
AND (NTRU,NIF) = NTRU
AND (NTRU,NTRU) = NTRU
AND (NTRU,AND) = NTRU
AND (NTRU,NIMP) = NTRU
AND (NTRU,XOR) = NTRU
AND (NTRU,IMP) = NTRU
AND (NTRU,NAND) = NTRU
AND (NTRU,TRU) = NTRU
AND (NTRU,IF) = NTRU
AND (NTRU,FIX) = NTRU
AND (NTRU,LET) = NTRU
AND (NTRU,NOR) = NTRU
AND (AND,LEQ) = AND
AND (AND,OR) = AND
AND (AND,DENY) = NTRU
AND (AND,FLIP) = NTRU
AND (AND,NIF) = NTRU
AND (AND,NTRU) = NTRU
AND (AND,AND) = AND
AND (AND,NIMP) = NTRU
AND (AND,XOR) = NTRU
AND (AND,IMP) = AND
AND (AND,NAND) = NTRU
AND (AND,TRU) = AND
AND (AND,IF) = AND
AND (AND,FIX) = AND
AND (AND,LET) = AND
AND (AND,NOR) = NTRU
AND (NIMP,LEQ) = NTRU
AND (NIMP,OR) = NIMP
AND (NIMP,DENY) = NIMP
AND (NIMP,FLIP) = NTRU
AND (NIMP,NIF) = NTRU
AND (NIMP,NTRU) = NTRU
AND (NIMP,AND) = NTRU
AND (NIMP,NIMP) = NIMP
AND (NIMP,XOR) = NIMP
AND (NIMP,IMP) = NTRU
AND (NIMP,NAND) = NIMP
AND (NIMP,TRU) = NIMP
AND (NIMP,IF) = NIMP
AND (NIMP,FIX) = NIMP
AND (NIMP,LET) = NTRU
AND (NIMP,NOR) = NTRU
AND (XOR,LEQ) = NTRU
AND (XOR,OR) = XOR
AND (XOR,DENY) = NIMP
AND (XOR,FLIP) = NIF
AND (XOR,NIF) = NIF
AND (XOR,NTRU) = NTRU
AND (XOR,AND) = NTRU
AND (XOR,NIMP) = NIMP
AND (XOR,XOR) = XOR
AND (XOR,IMP) = NIF
AND (XOR,NAND) = XOR
AND (XOR,TRU) = XOR
AND (XOR,IF) = NIMP
AND (XOR,FIX) = NIMP
AND (XOR,LET) = NIF
AND (XOR,NOR) = NTRU
AND (IMP,LEQ) = LEQ
AND (IMP,OR) = LET
AND (IMP,DENY) = NOR
AND (IMP,FLIP) = FLIP
AND (IMP,NIF) = NIF
AND (IMP,NTRU) = NTRU
AND (IMP,AND) = AND
AND (IMP,NIMP) = NTRU
AND (IMP,XOR) = NIF
AND (IMP,IMP) = IMP
AND (IMP,NAND) = FLIP
AND (IMP,TRU) = IMP
AND (IMP,IF) = LEQ
AND (IMP,FIX) = AND
AND (IMP,LET) = LET
AND (IMP,NOR) = NOR
AND (NAND,LEQ) = NOR
AND (NAND,OR) = XOR
AND (NAND,DENY) = DENY
AND (NAND,FLIP) = FLIP
AND (NAND,NIF) = NIF
AND (NAND,NTRU) = NTRU
AND (NAND,AND) = NTRU
AND (NAND,NIMP) = NIMP
AND (NAND,XOR) = XOR
AND (NAND,IMP) = FLIP
AND (NAND,NAND) = NAND
AND (NAND,TRU) = NAND
AND (NAND,IF) = DENY
AND (NAND,FIX) = NIMP
AND (NAND,LET) = NIF
AND (NAND,NOR) = NOR
AND (TRU,LEQ) = LEQ
AND (TRU,OR) = OR
AND (TRU,DENY) = DENY
AND (TRU,FLIP) = FLIP
AND (TRU,NIF) = NIF
AND (TRU,NTRU) = NTRU
AND (TRU,AND) = AND
AND (TRU,NIMP) = NIMP
AND (TRU,XOR) = XOR
AND (TRU,IMP) = IMP
AND (TRU,NAND) = NAND
AND (TRU,TRU) = TRU
AND (TRU,IF) = IF
AND (TRU,FIX) = FIX
AND (TRU,LET) = LET
AND (TRU,NOR) = NOR
AND (IF,LEQ) = LEQ
AND (IF,OR) = FIX
AND (IF,DENY) = DENY
AND (IF,FLIP) = NOR
AND (IF,NIF) = NTRU
AND (IF,NTRU) = NTRU
AND (IF,AND) = AND
AND (IF,NIMP) = NIMP
AND (IF,XOR) = NIMP
AND (IF,IMP) = LEQ
AND (IF,NAND) = DENY
AND (IF,TRU) = IF
AND (IF,IF) = IF
AND (IF,FIX) = FIX
AND (IF,LET) = AND
AND (IF,NOR) = NOR
AND (FIX,LEQ) = AND
AND (FIX,OR) = FIX
AND (FIX,DENY) = NIMP
AND (FIX,FLIP) = NTRU
AND (FIX,NIF) = NTRU
AND (FIX,NTRU) = NTRU
AND (FIX,AND) = AND
AND (FIX,NIMP) = NIMP
AND (FIX,XOR) = NIMP
AND (FIX,IMP) = AND
AND (FIX,NAND) = NIMP
AND (FIX,TRU) = FIX
AND (FIX,IF) = FIX
AND (FIX,FIX) = FIX
AND (FIX,LET) = AND
AND (FIX,NOR) = NTRU
AND (LET,LEQ) = AND
AND (LET,OR) = LET
AND (LET,DENY) = NTRU
AND (LET,FLIP) = NIF
AND (LET,NIF) = NIF
AND (LET,NTRU) = NTRU
AND (LET,AND) = AND
AND (LET,NIMP) = NTRU
AND (LET,XOR) = NIF
AND (LET,IMP) = LET
AND (LET,NAND) = NIF
AND (LET,TRU) = LET
AND (LET,IF) = AND
AND (LET,FIX) = AND
AND (LET,LET) = LET
AND (LET,NOR) = NTRU
AND (NOR,LEQ) = NOR
AND (NOR,OR) = NTRU
AND (NOR,DENY) = NOR
AND (NOR,FLIP) = NOR
AND (NOR,NIF) = NTRU
AND (NOR,NTRU) = NTRU
AND (NOR,AND) = NTRU
AND (NOR,NIMP) = NTRU
AND (NOR,XOR) = NTRU
AND (NOR,IMP) = NOR
AND (NOR,NAND) = NOR
AND (NOR,TRU) = NOR
AND (NOR,IF) = NOR
AND (NOR,FIX) = NTRU
AND (NOR,LET) = NTRU
AND (NOR,NOR) = NOR
NIMP (LEQ,LEQ) = NTRU
NIMP (LEQ,OR) = NOR
NIMP (LEQ,DENY) = AND
NIMP (LEQ,FLIP) = AND
NIMP (LEQ,NIF) = LEQ
NIMP (LEQ,NTRU) = LEQ
NIMP (LEQ,AND) = NOR
NIMP (LEQ,NIMP) = LEQ
NIMP (LEQ,XOR) = LEQ
NIMP (LEQ,IMP) = NTRU
NIMP (LEQ,NAND) = AND
NIMP (LEQ,TRU) = NTRU
NIMP (LEQ,IF) = NTRU
NIMP (LEQ,FIX) = NOR
NIMP (LEQ,LET) = NOR
NIMP (LEQ,NOR) = AND
NIMP (OR,LEQ) = XOR
NIMP (OR,OR) = NTRU
NIMP (OR,DENY) = LET
NIMP (OR,FLIP) = FIX
NIMP (OR,NIF) = FIX
NIMP (OR,NTRU) = OR
NIMP (OR,AND) = XOR
NIMP (OR,NIMP) = LET
NIMP (OR,XOR) = AND
NIMP (OR,IMP) = NIMP
NIMP (OR,NAND) = AND
NIMP (OR,TRU) = NTRU
NIMP (OR,IF) = NIF
NIMP (OR,FIX) = NIF
NIMP (OR,LET) = NIMP
NIMP (OR,NOR) = OR
NIMP (DENY,LEQ) = NIMP
NIMP (DENY,OR) = NOR
NIMP (DENY,DENY) = NTRU
NIMP (DENY,FLIP) = NIMP
NIMP (DENY,NIF) = DENY
NIMP (DENY,NTRU) = DENY
NIMP (DENY,AND) = DENY
NIMP (DENY,NIMP) = NOR
NIMP (DENY,XOR) = NOR
NIMP (DENY,IMP) = NIMP
NIMP (DENY,NAND) = NTRU
NIMP (DENY,TRU) = NTRU
NIMP (DENY,IF) = NTRU
NIMP (DENY,FIX) = NOR
NIMP (DENY,LET) = DENY
NIMP (DENY,NOR) = NIMP
NIMP (FLIP,LEQ) = NIF
NIMP (FLIP,OR) = NOR
NIMP (FLIP,DENY) = NIF
NIMP (FLIP,FLIP) = NTRU
NIMP (FLIP,NIF) = NOR
NIMP (FLIP,NTRU) = FLIP
NIMP (FLIP,AND) = FLIP
NIMP (FLIP,NIMP) = FLIP
NIMP (FLIP,XOR) = NOR
NIMP (FLIP,IMP) = NTRU
NIMP (FLIP,NAND) = NTRU
NIMP (FLIP,TRU) = NTRU
NIMP (FLIP,IF) = NIF
NIMP (FLIP,FIX) = FLIP
NIMP (FLIP,LET) = NOR
NIMP (FLIP,NOR) = NIF
NIMP (NIF,LEQ) = NIF
NIMP (NIF,OR) = NTRU
NIMP (NIF,DENY) = NIF
NIMP (NIF,FLIP) = NTRU
NIMP (NIF,NIF) = NTRU
NIMP (NIF,NTRU) = NIF
NIMP (NIF,AND) = NIF
NIMP (NIF,NIMP) = NIF
NIMP (NIF,XOR) = NTRU
NIMP (NIF,IMP) = NTRU
NIMP (NIF,NAND) = NTRU
NIMP (NIF,TRU) = NTRU
NIMP (NIF,IF) = NIF
NIMP (NIF,FIX) = NIF
NIMP (NIF,LET) = NTRU
NIMP (NIF,NOR) = NIF
NIMP (NTRU,LEQ) = NTRU
NIMP (NTRU,OR) = NTRU
NIMP (NTRU,DENY) = NTRU
NIMP (NTRU,FLIP) = NTRU
NIMP (NTRU,NIF) = NTRU
NIMP (NTRU,NTRU) = NTRU
NIMP (NTRU,AND) = NTRU
NIMP (NTRU,NIMP) = NTRU
NIMP (NTRU,XOR) = NTRU
NIMP (NTRU,IMP) = NTRU
NIMP (NTRU,NAND) = NTRU
NIMP (NTRU,TRU) = NTRU
NIMP (NTRU,IF) = NTRU
NIMP (NTRU,FIX) = NTRU
NIMP (NTRU,LET) = NTRU
NIMP (NTRU,NOR) = NTRU
NIMP (AND,LEQ) = NTRU
NIMP (AND,OR) = NTRU
NIMP (AND,DENY) = AND
NIMP (AND,FLIP) = AND
NIMP (AND,NIF) = AND
NIMP (AND,NTRU) = AND
NIMP (AND,AND) = NTRU
NIMP (AND,NIMP) = AND
NIMP (AND,XOR) = AND
NIMP (AND,IMP) = NTRU
NIMP (AND,NAND) = AND
NIMP (AND,TRU) = NTRU
NIMP (AND,IF) = NTRU
NIMP (AND,FIX) = NTRU
NIMP (AND,LET) = NTRU
NIMP (AND,NOR) = AND
NIMP (NIMP,LEQ) = NIMP
NIMP (NIMP,OR) = NTRU
NIMP (NIMP,DENY) = NTRU
NIMP (NIMP,FLIP) = NIMP
NIMP (NIMP,NIF) = NIMP
NIMP (NIMP,NTRU) = NIMP
NIMP (NIMP,AND) = NIMP
NIMP (NIMP,NIMP) = NTRU
NIMP (NIMP,XOR) = NTRU
NIMP (NIMP,IMP) = NIMP
NIMP (NIMP,NAND) = NTRU
NIMP (NIMP,TRU) = NTRU
NIMP (NIMP,IF) = NTRU
NIMP (NIMP,FIX) = NTRU
NIMP (NIMP,LET) = NIMP
NIMP (NIMP,NOR) = NIMP
NIMP (XOR,LEQ) = XOR
NIMP (XOR,OR) = NTRU
NIMP (XOR,DENY) = NIF
NIMP (XOR,FLIP) = NIMP
NIMP (XOR,NIF) = NIMP
NIMP (XOR,NTRU) = XOR
NIMP (XOR,AND) = XOR
NIMP (XOR,NIMP) = NIF
NIMP (XOR,XOR) = NTRU
NIMP (XOR,IMP) = NIMP
NIMP (XOR,NAND) = NTRU
NIMP (XOR,TRU) = NTRU
NIMP (XOR,IF) = NIF
NIMP (XOR,FIX) = NIF
NIMP (XOR,LET) = NIMP
NIMP (XOR,NOR) = XOR
NIMP (IMP,LEQ) = NIF
NIMP (IMP,OR) = NOR
NIMP (IMP,DENY) = LET
NIMP (IMP,FLIP) = AND
NIMP (IMP,NIF) = LEQ
NIMP (IMP,NTRU) = IMP
NIMP (IMP,AND) = FLIP
NIMP (IMP,NIMP) = IMP
NIMP (IMP,XOR) = LEQ
NIMP (IMP,IMP) = NTRU
NIMP (IMP,NAND) = AND
NIMP (IMP,TRU) = NTRU
NIMP (IMP,IF) = NIF
NIMP (IMP,FIX) = FLIP
NIMP (IMP,LET) = NOR
NIMP (IMP,NOR) = LET
NIMP (NAND,LEQ) = XOR
NIMP (NAND,OR) = NOR
NIMP (NAND,DENY) = NIF
NIMP (NAND,FLIP) = NIMP
NIMP (NAND,NIF) = DENY
NIMP (NAND,NTRU) = NAND
NIMP (NAND,AND) = NAND
NIMP (NAND,NIMP) = FLIP
NIMP (NAND,XOR) = NOR
NIMP (NAND,IMP) = NIMP
NIMP (NAND,NAND) = NTRU
NIMP (NAND,TRU) = NTRU
NIMP (NAND,IF) = NIF
NIMP (NAND,FIX) = FLIP
NIMP (NAND,LET) = DENY
NIMP (NAND,NOR) = XOR
NIMP (TRU,LEQ) = XOR
NIMP (TRU,OR) = NOR
NIMP (TRU,DENY) = LET
NIMP (TRU,FLIP) = FIX
NIMP (TRU,NIF) = IF
NIMP (TRU,NTRU) = TRU
NIMP (TRU,AND) = NAND
NIMP (TRU,NIMP) = IMP
NIMP (TRU,XOR) = LEQ
NIMP (TRU,IMP) = NIMP
NIMP (TRU,NAND) = AND
NIMP (TRU,TRU) = NTRU
NIMP (TRU,IF) = NIF
NIMP (TRU,FIX) = FLIP
NIMP (TRU,LET) = DENY
NIMP (TRU,NOR) = OR
NIMP (IF,LEQ) = NIMP
NIMP (IF,OR) = NOR
NIMP (IF,DENY) = AND
NIMP (IF,FLIP) = FIX
NIMP (IF,NIF) = IF
NIMP (IF,NTRU) = IF
NIMP (IF,AND) = DENY
NIMP (IF,NIMP) = LEQ
NIMP (IF,XOR) = LEQ
NIMP (IF,IMP) = NIMP
NIMP (IF,NAND) = AND
NIMP (IF,TRU) = NTRU
NIMP (IF,IF) = NTRU
NIMP (IF,FIX) = NOR
NIMP (IF,LET) = DENY
NIMP (IF,NOR) = FIX
NIMP (FIX,LEQ) = NIMP
NIMP (FIX,OR) = NTRU
NIMP (FIX,DENY) = AND
NIMP (FIX,FLIP) = FIX
NIMP (FIX,NIF) = FIX
NIMP (FIX,NTRU) = FIX
NIMP (FIX,AND) = NIMP
NIMP (FIX,NIMP) = AND
NIMP (FIX,XOR) = AND
NIMP (FIX,IMP) = NIMP
NIMP (FIX,NAND) = AND
NIMP (FIX,TRU) = NTRU
NIMP (FIX,IF) = NTRU
NIMP (FIX,FIX) = NTRU
NIMP (FIX,LET) = NIMP
NIMP (FIX,NOR) = FIX
NIMP (LET,LEQ) = NIF
NIMP (LET,OR) = NTRU
NIMP (LET,DENY) = LET
NIMP (LET,FLIP) = AND
NIMP (LET,NIF) = AND
NIMP (LET,NTRU) = LET
NIMP (LET,AND) = NIF
NIMP (LET,NIMP) = LET
NIMP (LET,XOR) = AND
NIMP (LET,IMP) = NTRU
NIMP (LET,NAND) = AND
NIMP (LET,TRU) = NTRU
NIMP (LET,IF) = NIF
NIMP (LET,FIX) = NIF
NIMP (LET,LET) = NTRU
NIMP (LET,NOR) = LET
NIMP (NOR,LEQ) = NTRU
NIMP (NOR,OR) = NOR
NIMP (NOR,DENY) = NTRU
NIMP (NOR,FLIP) = NTRU
NIMP (NOR,NIF) = NOR
NIMP (NOR,NTRU) = NOR
NIMP (NOR,AND) = NOR
NIMP (NOR,NIMP) = NOR
NIMP (NOR,XOR) = NOR
NIMP (NOR,IMP) = NTRU
NIMP (NOR,NAND) = NTRU
NIMP (NOR,TRU) = NTRU
NIMP (NOR,IF) = NTRU
NIMP (NOR,FIX) = NOR
NIMP (NOR,LET) = NOR
NIMP (NOR,NOR) = NTRU
XOR (LEQ,LEQ) = NTRU
XOR (LEQ,OR) = NAND
XOR (LEQ,DENY) = FIX
XOR (LEQ,FLIP) = LET
XOR (LEQ,NIF) = IMP
XOR (LEQ,NTRU) = LEQ
XOR (LEQ,AND) = NOR
XOR (LEQ,NIMP) = IF
XOR (LEQ,XOR) = TRU
XOR (LEQ,IMP) = NIF
XOR (LEQ,NAND) = OR
XOR (LEQ,TRU) = XOR
XOR (LEQ,IF) = NIMP
XOR (LEQ,FIX) = DENY
XOR (LEQ,LET) = FLIP
XOR (LEQ,NOR) = AND
XOR (OR,LEQ) = NAND
XOR (OR,OR) = NTRU
XOR (OR,DENY) = IMP
XOR (OR,FLIP) = IF
XOR (OR,NIF) = FIX
XOR (OR,NTRU) = OR
XOR (OR,AND) = XOR
XOR (OR,NIMP) = LET
XOR (OR,XOR) = AND
XOR (OR,IMP) = DENY
XOR (OR,NAND) = LEQ
XOR (OR,TRU) = NOR
XOR (OR,IF) = FLIP
XOR (OR,FIX) = NIF
XOR (OR,LET) = NIMP
XOR (OR,NOR) = TRU
XOR (DENY,LEQ) = FIX
XOR (DENY,OR) = IMP
XOR (DENY,DENY) = NTRU
XOR (DENY,FLIP) = XOR
XOR (DENY,NIF) = NAND
XOR (DENY,NTRU) = DENY
XOR (DENY,AND) = IF
XOR (DENY,NIMP) = NOR
XOR (DENY,XOR) = FLIP
XOR (DENY,IMP) = OR
XOR (DENY,NAND) = NIF
XOR (DENY,TRU) = LET
XOR (DENY,IF) = AND
XOR (DENY,FIX) = LEQ
XOR (DENY,LET) = TRU
XOR (DENY,NOR) = NIMP
XOR (FLIP,LEQ) = LET
XOR (FLIP,OR) = IF
XOR (FLIP,DENY) = XOR
XOR (FLIP,FLIP) = NTRU
XOR (FLIP,NIF) = NOR
XOR (FLIP,NTRU) = FLIP
XOR (FLIP,AND) = IMP
XOR (FLIP,NIMP) = NAND
XOR (FLIP,XOR) = DENY
XOR (FLIP,IMP) = AND
XOR (FLIP,NAND) = NIMP
XOR (FLIP,TRU) = FIX
XOR (FLIP,IF) = OR
XOR (FLIP,FIX) = TRU
XOR (FLIP,LET) = LEQ
XOR (FLIP,NOR) = NIF
XOR (NIF,LEQ) = IMP
XOR (NIF,OR) = FIX
XOR (NIF,DENY) = NAND
XOR (NIF,FLIP) = NOR
XOR (NIF,NIF) = NTRU
XOR (NIF,NTRU) = NIF
XOR (NIF,AND) = LET
XOR (NIF,NIMP) = XOR
XOR (NIF,XOR) = NIMP
XOR (NIF,IMP) = LEQ
XOR (NIF,NAND) = DENY
XOR (NIF,TRU) = IF
XOR (NIF,IF) = TRU
XOR (NIF,FIX) = OR
XOR (NIF,LET) = AND
XOR (NIF,NOR) = FLIP
XOR (NTRU,LEQ) = LEQ
XOR (NTRU,OR) = OR
XOR (NTRU,DENY) = DENY
XOR (NTRU,FLIP) = FLIP
XOR (NTRU,NIF) = NIF
XOR (NTRU,NTRU) = NTRU
XOR (NTRU,AND) = AND
XOR (NTRU,NIMP) = NIMP
XOR (NTRU,XOR) = XOR
XOR (NTRU,IMP) = IMP
XOR (NTRU,NAND) = NAND
XOR (NTRU,TRU) = TRU
XOR (NTRU,IF) = IF
XOR (NTRU,FIX) = FIX
XOR (NTRU,LET) = LET
XOR (NTRU,NOR) = NOR
XOR (AND,LEQ) = NOR
XOR (AND,OR) = XOR
XOR (AND,DENY) = IF
XOR (AND,FLIP) = IMP
XOR (AND,NIF) = LET
XOR (AND,NTRU) = AND
XOR (AND,AND) = NTRU
XOR (AND,NIMP) = FIX
XOR (AND,XOR) = OR
XOR (AND,IMP) = FLIP
XOR (AND,NAND) = TRU
XOR (AND,TRU) = NAND
XOR (AND,IF) = DENY
XOR (AND,FIX) = NIMP
XOR (AND,LET) = NIF
XOR (AND,NOR) = LEQ
XOR (NIMP,LEQ) = IF
XOR (NIMP,OR) = LET
XOR (NIMP,DENY) = NOR
XOR (NIMP,FLIP) = NAND
XOR (NIMP,NIF) = XOR
XOR (NIMP,NTRU) = NIMP
XOR (NIMP,AND) = FIX
XOR (NIMP,NIMP) = NTRU
XOR (NIMP,XOR) = NIF
XOR (NIMP,IMP) = TRU
XOR (NIMP,NAND) = FLIP
XOR (NIMP,TRU) = IMP
XOR (NIMP,IF) = LEQ
XOR (NIMP,FIX) = AND
XOR (NIMP,LET) = OR
XOR (NIMP,NOR) = DENY
XOR (XOR,LEQ) = TRU
XOR (XOR,OR) = AND
XOR (XOR,DENY) = FLIP
XOR (XOR,FLIP) = DENY
XOR (XOR,NIF) = NIMP
XOR (XOR,NTRU) = XOR
XOR (XOR,AND) = OR
XOR (XOR,NIMP) = NIF
XOR (XOR,XOR) = NTRU
XOR (XOR,IMP) = IF
XOR (XOR,NAND) = NOR
XOR (XOR,TRU) = LEQ
XOR (XOR,IF) = IMP
XOR (XOR,FIX) = LET
XOR (XOR,LET) = FIX
XOR (XOR,NOR) = NAND
XOR (IMP,LEQ) = NIF
XOR (IMP,OR) = DENY
XOR (IMP,DENY) = OR
XOR (IMP,FLIP) = AND
XOR (IMP,NIF) = LEQ
XOR (IMP,NTRU) = IMP
XOR (IMP,AND) = FLIP
XOR (IMP,NIMP) = TRU
XOR (IMP,XOR) = IF
XOR (IMP,IMP) = NTRU
XOR (IMP,NAND) = FIX
XOR (IMP,TRU) = NIMP
XOR (IMP,IF) = XOR
XOR (IMP,FIX) = NAND
XOR (IMP,LET) = NOR
XOR (IMP,NOR) = LET
XOR (NAND,LEQ) = OR
XOR (NAND,OR) = LEQ
XOR (NAND,DENY) = NIF
XOR (NAND,FLIP) = NIMP
XOR (NAND,NIF) = DENY
XOR (NAND,NTRU) = NAND
XOR (NAND,AND) = TRU
XOR (NAND,NIMP) = FLIP
XOR (NAND,XOR) = NOR
XOR (NAND,IMP) = FIX
XOR (NAND,NAND) = NTRU
XOR (NAND,TRU) = AND
XOR (NAND,IF) = LET
XOR (NAND,FIX) = IMP
XOR (NAND,LET) = IF
XOR (NAND,NOR) = XOR
XOR (TRU,LEQ) = XOR
XOR (TRU,OR) = NOR
XOR (TRU,DENY) = LET
XOR (TRU,FLIP) = FIX
XOR (TRU,NIF) = IF
XOR (TRU,NTRU) = TRU
XOR (TRU,AND) = NAND
XOR (TRU,NIMP) = IMP
XOR (TRU,XOR) = LEQ
XOR (TRU,IMP) = NIMP
XOR (TRU,NAND) = AND
XOR (TRU,TRU) = NTRU
XOR (TRU,IF) = NIF
XOR (TRU,FIX) = FLIP
XOR (TRU,LET) = DENY
XOR (TRU,NOR) = OR
XOR (IF,LEQ) = NIMP
XOR (IF,OR) = FLIP
XOR (IF,DENY) = AND
XOR (IF,FLIP) = OR
XOR (IF,NIF) = TRU
XOR (IF,NTRU) = IF
XOR (IF,AND) = DENY
XOR (IF,NIMP) = LEQ
XOR (IF,XOR) = IMP
XOR (IF,IMP) = XOR
XOR (IF,NAND) = LET
XOR (IF,TRU) = NIF
XOR (IF,IF) = NTRU
XOR (IF,FIX) = NOR
XOR (IF,LET) = NAND
XOR (IF,NOR) = FIX
XOR (FIX,LEQ) = DENY
XOR (FIX,OR) = NIF
XOR (FIX,DENY) = LEQ
XOR (FIX,FLIP) = TRU
XOR (FIX,NIF) = OR
XOR (FIX,NTRU) = FIX
XOR (FIX,AND) = NIMP
XOR (FIX,NIMP) = AND
XOR (FIX,XOR) = LET
XOR (FIX,IMP) = NAND
XOR (FIX,NAND) = IMP
XOR (FIX,TRU) = FLIP
XOR (FIX,IF) = NOR
XOR (FIX,FIX) = NTRU
XOR (FIX,LET) = XOR
XOR (FIX,NOR) = IF
XOR (LET,LEQ) = FLIP
XOR (LET,OR) = NIMP
XOR (LET,DENY) = TRU
XOR (LET,FLIP) = LEQ
XOR (LET,NIF) = AND
XOR (LET,NTRU) = LET
XOR (LET,AND) = NIF
XOR (LET,NIMP) = OR
XOR (LET,XOR) = FIX
XOR (LET,IMP) = NOR
XOR (LET,NAND) = IF
XOR (LET,TRU) = DENY
XOR (LET,IF) = NAND
XOR (LET,FIX) = XOR
XOR (LET,LET) = NTRU
XOR (LET,NOR) = IMP
XOR (NOR,LEQ) = AND
XOR (NOR,OR) = TRU
XOR (NOR,DENY) = NIMP
XOR (NOR,FLIP) = NIF
XOR (NOR,NIF) = FLIP
XOR (NOR,NTRU) = NOR
XOR (NOR,AND) = LEQ
XOR (NOR,NIMP) = DENY
XOR (NOR,XOR) = NAND
XOR (NOR,IMP) = LET
XOR (NOR,NAND) = XOR
XOR (NOR,TRU) = OR
XOR (NOR,IF) = FIX
XOR (NOR,FIX) = IF
XOR (NOR,LET) = IMP
XOR (NOR,NOR) = NTRU
IMP (LEQ,LEQ) = TRU
IMP (LEQ,OR) = OR
IMP (LEQ,DENY) = NAND
IMP (LEQ,FLIP) = NAND
IMP (LEQ,NIF) = XOR
IMP (LEQ,NTRU) = XOR
IMP (LEQ,AND) = OR
IMP (LEQ,NIMP) = XOR
IMP (LEQ,XOR) = XOR
IMP (LEQ,IMP) = TRU
IMP (LEQ,NAND) = NAND
IMP (LEQ,TRU) = TRU
IMP (LEQ,IF) = TRU
IMP (LEQ,FIX) = OR
IMP (LEQ,LET) = OR
IMP (LEQ,NOR) = NAND
IMP (OR,LEQ) = LEQ
IMP (OR,OR) = TRU
IMP (OR,DENY) = DENY
IMP (OR,FLIP) = FLIP
IMP (OR,NIF) = FLIP
IMP (OR,NTRU) = NOR
IMP (OR,AND) = LEQ
IMP (OR,NIMP) = DENY
IMP (OR,XOR) = NAND
IMP (OR,IMP) = IMP
IMP (OR,NAND) = NAND
IMP (OR,TRU) = TRU
IMP (OR,IF) = IF
IMP (OR,FIX) = IF
IMP (OR,LET) = IMP
IMP (OR,NOR) = NOR
IMP (DENY,LEQ) = IMP
IMP (DENY,OR) = OR
IMP (DENY,DENY) = TRU
IMP (DENY,FLIP) = IMP
IMP (DENY,NIF) = LET
IMP (DENY,NTRU) = LET
IMP (DENY,AND) = LET
IMP (DENY,NIMP) = OR
IMP (DENY,XOR) = OR
IMP (DENY,IMP) = IMP
IMP (DENY,NAND) = TRU
IMP (DENY,TRU) = TRU
IMP (DENY,IF) = TRU
IMP (DENY,FIX) = OR
IMP (DENY,LET) = LET
IMP (DENY,NOR) = IMP
IMP (FLIP,LEQ) = IF
IMP (FLIP,OR) = OR
IMP (FLIP,DENY) = IF
IMP (FLIP,FLIP) = TRU
IMP (FLIP,NIF) = OR
IMP (FLIP,NTRU) = FIX
IMP (FLIP,AND) = FIX
IMP (FLIP,NIMP) = FIX
IMP (FLIP,XOR) = OR
IMP (FLIP,IMP) = TRU
IMP (FLIP,NAND) = TRU
IMP (FLIP,TRU) = TRU
IMP (FLIP,IF) = IF
IMP (FLIP,FIX) = FIX
IMP (FLIP,LET) = OR
IMP (FLIP,NOR) = IF
IMP (NIF,LEQ) = IF
IMP (NIF,OR) = TRU
IMP (NIF,DENY) = IF
IMP (NIF,FLIP) = TRU
IMP (NIF,NIF) = TRU
IMP (NIF,NTRU) = IF
IMP (NIF,AND) = IF
IMP (NIF,NIMP) = IF
IMP (NIF,XOR) = TRU
IMP (NIF,IMP) = TRU
IMP (NIF,NAND) = TRU
IMP (NIF,TRU) = TRU
IMP (NIF,IF) = IF
IMP (NIF,FIX) = IF
IMP (NIF,LET) = TRU
IMP (NIF,NOR) = IF
IMP (NTRU,LEQ) = TRU
IMP (NTRU,OR) = TRU
IMP (NTRU,DENY) = TRU
IMP (NTRU,FLIP) = TRU
IMP (NTRU,NIF) = TRU
IMP (NTRU,NTRU) = TRU
IMP (NTRU,AND) = TRU
IMP (NTRU,NIMP) = TRU
IMP (NTRU,XOR) = TRU
IMP (NTRU,IMP) = TRU
IMP (NTRU,NAND) = TRU
IMP (NTRU,TRU) = TRU
IMP (NTRU,IF) = TRU
IMP (NTRU,FIX) = TRU
IMP (NTRU,LET) = TRU
IMP (NTRU,NOR) = TRU
IMP (AND,LEQ) = TRU
IMP (AND,OR) = TRU
IMP (AND,DENY) = NAND
IMP (AND,FLIP) = NAND
IMP (AND,NIF) = NAND
IMP (AND,NTRU) = NAND
IMP (AND,AND) = TRU
IMP (AND,NIMP) = NAND
IMP (AND,XOR) = NAND
IMP (AND,IMP) = TRU
IMP (AND,NAND) = NAND
IMP (AND,TRU) = TRU
IMP (AND,IF) = TRU
IMP (AND,FIX) = TRU
IMP (AND,LET) = TRU
IMP (AND,NOR) = NAND
IMP (NIMP,LEQ) = IMP
IMP (NIMP,OR) = TRU
IMP (NIMP,DENY) = TRU
IMP (NIMP,FLIP) = IMP
IMP (NIMP,NIF) = IMP
IMP (NIMP,NTRU) = IMP
IMP (NIMP,AND) = IMP
IMP (NIMP,NIMP) = TRU
IMP (NIMP,XOR) = TRU
IMP (NIMP,IMP) = IMP
IMP (NIMP,NAND) = TRU
IMP (NIMP,TRU) = TRU
IMP (NIMP,IF) = TRU
IMP (NIMP,FIX) = TRU
IMP (NIMP,LET) = IMP
IMP (NIMP,NOR) = IMP
IMP (XOR,LEQ) = LEQ
IMP (XOR,OR) = TRU
IMP (XOR,DENY) = IF
IMP (XOR,FLIP) = IMP
IMP (XOR,NIF) = IMP
IMP (XOR,NTRU) = LEQ
IMP (XOR,AND) = LEQ
IMP (XOR,NIMP) = IF
IMP (XOR,XOR) = TRU
IMP (XOR,IMP) = IMP
IMP (XOR,NAND) = TRU
IMP (XOR,TRU) = TRU
IMP (XOR,IF) = IF
IMP (XOR,FIX) = IF
IMP (XOR,LET) = IMP
IMP (XOR,NOR) = LEQ
IMP (IMP,LEQ) = IF
IMP (IMP,OR) = OR
IMP (IMP,DENY) = DENY
IMP (IMP,FLIP) = NAND
IMP (IMP,NIF) = XOR
IMP (IMP,NTRU) = NIMP
IMP (IMP,AND) = FIX
IMP (IMP,NIMP) = NIMP
IMP (IMP,XOR) = XOR
IMP (IMP,IMP) = TRU
IMP (IMP,NAND) = NAND
IMP (IMP,TRU) = TRU
IMP (IMP,IF) = IF
IMP (IMP,FIX) = FIX
IMP (IMP,LET) = OR
IMP (IMP,NOR) = DENY
IMP (NAND,LEQ) = LEQ
IMP (NAND,OR) = OR
IMP (NAND,DENY) = IF
IMP (NAND,FLIP) = IMP
IMP (NAND,NIF) = LET
IMP (NAND,NTRU) = AND
IMP (NAND,AND) = AND
IMP (NAND,NIMP) = FIX
IMP (NAND,XOR) = OR
IMP (NAND,IMP) = IMP
IMP (NAND,NAND) = TRU
IMP (NAND,TRU) = TRU
IMP (NAND,IF) = IF
IMP (NAND,FIX) = FIX
IMP (NAND,LET) = LET
IMP (NAND,NOR) = LEQ
IMP (TRU,LEQ) = LEQ
IMP (TRU,OR) = OR
IMP (TRU,DENY) = DENY
IMP (TRU,FLIP) = FLIP
IMP (TRU,NIF) = NIF
IMP (TRU,NTRU) = NTRU
IMP (TRU,AND) = AND
IMP (TRU,NIMP) = NIMP
IMP (TRU,XOR) = XOR
IMP (TRU,IMP) = IMP
IMP (TRU,NAND) = NAND
IMP (TRU,TRU) = TRU
IMP (TRU,IF) = IF
IMP (TRU,FIX) = FIX
IMP (TRU,LET) = LET
IMP (TRU,NOR) = NOR
IMP (IF,LEQ) = IMP
IMP (IF,OR) = OR
IMP (IF,DENY) = NAND
IMP (IF,FLIP) = FLIP
IMP (IF,NIF) = NIF
IMP (IF,NTRU) = NIF
IMP (IF,AND) = LET
IMP (IF,NIMP) = XOR
IMP (IF,XOR) = XOR
IMP (IF,IMP) = IMP
IMP (IF,NAND) = NAND
IMP (IF,TRU) = TRU
IMP (IF,IF) = TRU
IMP (IF,FIX) = OR
IMP (IF,LET) = LET
IMP (IF,NOR) = FLIP
IMP (FIX,LEQ) = IMP
IMP (FIX,OR) = TRU
IMP (FIX,DENY) = NAND
IMP (FIX,FLIP) = FLIP
IMP (FIX,NIF) = FLIP
IMP (FIX,NTRU) = FLIP
IMP (FIX,AND) = IMP
IMP (FIX,NIMP) = NAND
IMP (FIX,XOR) = NAND
IMP (FIX,IMP) = IMP
IMP (FIX,NAND) = NAND
IMP (FIX,TRU) = TRU
IMP (FIX,IF) = TRU
IMP (FIX,FIX) = TRU
IMP (FIX,LET) = IMP
IMP (FIX,NOR) = FLIP
IMP (LET,LEQ) = IF
IMP (LET,OR) = TRU
IMP (LET,DENY) = DENY
IMP (LET,FLIP) = NAND
IMP (LET,NIF) = NAND
IMP (LET,NTRU) = DENY
IMP (LET,AND) = IF
IMP (LET,NIMP) = DENY
IMP (LET,XOR) = NAND
IMP (LET,IMP) = TRU
IMP (LET,NAND) = NAND
IMP (LET,TRU) = TRU
IMP (LET,IF) = IF
IMP (LET,FIX) = IF
IMP (LET,LET) = TRU
IMP (LET,NOR) = DENY
IMP (NOR,LEQ) = TRU
IMP (NOR,OR) = OR
IMP (NOR,DENY) = TRU
IMP (NOR,FLIP) = TRU
IMP (NOR,NIF) = OR
IMP (NOR,NTRU) = OR
IMP (NOR,AND) = OR
IMP (NOR,NIMP) = OR
IMP (NOR,XOR) = OR
IMP (NOR,IMP) = TRU
IMP (NOR,NAND) = TRU
IMP (NOR,TRU) = TRU
IMP (NOR,IF) = TRU
IMP (NOR,FIX) = OR
IMP (NOR,LET) = OR
IMP (NOR,NOR) = TRU
NAND (LEQ,LEQ) = XOR
NAND (LEQ,OR) = NAND
NAND (LEQ,DENY) = OR
NAND (LEQ,FLIP) = OR
NAND (LEQ,NIF) = TRU
NAND (LEQ,NTRU) = TRU
NAND (LEQ,AND) = NAND
NAND (LEQ,NIMP) = TRU
NAND (LEQ,XOR) = TRU
NAND (LEQ,IMP) = XOR
NAND (LEQ,NAND) = OR
NAND (LEQ,TRU) = XOR
NAND (LEQ,IF) = XOR
NAND (LEQ,FIX) = NAND
NAND (LEQ,LET) = NAND
NAND (LEQ,NOR) = OR
NAND (OR,LEQ) = NAND
NAND (OR,OR) = NOR
NAND (OR,DENY) = IMP
NAND (OR,FLIP) = IF
NAND (OR,NIF) = IF
NAND (OR,NTRU) = TRU
NAND (OR,AND) = NAND
NAND (OR,NIMP) = IMP
NAND (OR,XOR) = LEQ
NAND (OR,IMP) = DENY
NAND (OR,NAND) = LEQ
NAND (OR,TRU) = NOR
NAND (OR,IF) = FLIP
NAND (OR,FIX) = FLIP
NAND (OR,LET) = DENY
NAND (OR,NOR) = TRU
NAND (DENY,LEQ) = OR
NAND (DENY,OR) = IMP
NAND (DENY,DENY) = LET
NAND (DENY,FLIP) = OR
NAND (DENY,NIF) = TRU
NAND (DENY,NTRU) = TRU
NAND (DENY,AND) = TRU
NAND (DENY,NIMP) = IMP
NAND (DENY,XOR) = IMP
NAND (DENY,IMP) = OR
NAND (DENY,NAND) = LET
NAND (DENY,TRU) = LET
NAND (DENY,IF) = LET
NAND (DENY,FIX) = IMP
NAND (DENY,LET) = TRU
NAND (DENY,NOR) = OR
NAND (FLIP,LEQ) = OR
NAND (FLIP,OR) = IF
NAND (FLIP,DENY) = OR
NAND (FLIP,FLIP) = FIX
NAND (FLIP,NIF) = IF
NAND (FLIP,NTRU) = TRU
NAND (FLIP,AND) = TRU
NAND (FLIP,NIMP) = TRU
NAND (FLIP,XOR) = IF
NAND (FLIP,IMP) = FIX
NAND (FLIP,NAND) = FIX
NAND (FLIP,TRU) = FIX
NAND (FLIP,IF) = OR
NAND (FLIP,FIX) = TRU
NAND (FLIP,LET) = IF
NAND (FLIP,NOR) = OR
NAND (NIF,LEQ) = TRU
NAND (NIF,OR) = IF
NAND (NIF,DENY) = TRU
NAND (NIF,FLIP) = IF
NAND (NIF,NIF) = IF
NAND (NIF,NTRU) = TRU
NAND (NIF,AND) = TRU
NAND (NIF,NIMP) = TRU
NAND (NIF,XOR) = IF
NAND (NIF,IMP) = IF
NAND (NIF,NAND) = IF
NAND (NIF,TRU) = IF
NAND (NIF,IF) = TRU
NAND (NIF,FIX) = TRU
NAND (NIF,LET) = IF
NAND (NIF,NOR) = TRU
NAND (NTRU,LEQ) = TRU
NAND (NTRU,OR) = TRU
NAND (NTRU,DENY) = TRU
NAND (NTRU,FLIP) = TRU
NAND (NTRU,NIF) = TRU
NAND (NTRU,NTRU) = TRU
NAND (NTRU,AND) = TRU
NAND (NTRU,NIMP) = TRU
NAND (NTRU,XOR) = TRU
NAND (NTRU,IMP) = TRU
NAND (NTRU,NAND) = TRU
NAND (NTRU,TRU) = TRU
NAND (NTRU,IF) = TRU
NAND (NTRU,FIX) = TRU
NAND (NTRU,LET) = TRU
NAND (NTRU,NOR) = TRU
NAND (AND,LEQ) = NAND
NAND (AND,OR) = NAND
NAND (AND,DENY) = TRU
NAND (AND,FLIP) = TRU
NAND (AND,NIF) = TRU
NAND (AND,NTRU) = TRU
NAND (AND,AND) = NAND
NAND (AND,NIMP) = TRU
NAND (AND,XOR) = TRU
NAND (AND,IMP) = NAND
NAND (AND,NAND) = TRU
NAND (AND,TRU) = NAND
NAND (AND,IF) = NAND
NAND (AND,FIX) = NAND
NAND (AND,LET) = NAND
NAND (AND,NOR) = TRU
NAND (NIMP,LEQ) = TRU
NAND (NIMP,OR) = IMP
NAND (NIMP,DENY) = IMP
NAND (NIMP,FLIP) = TRU
NAND (NIMP,NIF) = TRU
NAND (NIMP,NTRU) = TRU
NAND (NIMP,AND) = TRU
NAND (NIMP,NIMP) = IMP
NAND (NIMP,XOR) = IMP
NAND (NIMP,IMP) = TRU
NAND (NIMP,NAND) = IMP
NAND (NIMP,TRU) = IMP
NAND (NIMP,IF) = IMP
NAND (NIMP,FIX) = IMP
NAND (NIMP,LET) = TRU
NAND (NIMP,NOR) = TRU
NAND (XOR,LEQ) = TRU
NAND (XOR,OR) = LEQ
NAND (XOR,DENY) = IMP
NAND (XOR,FLIP) = IF
NAND (XOR,NIF) = IF
NAND (XOR,NTRU) = TRU
NAND (XOR,AND) = TRU
NAND (XOR,NIMP) = IMP
NAND (XOR,XOR) = LEQ
NAND (XOR,IMP) = IF
NAND (XOR,NAND) = LEQ
NAND (XOR,TRU) = LEQ
NAND (XOR,IF) = IMP
NAND (XOR,FIX) = IMP
NAND (XOR,LET) = IF
NAND (XOR,NOR) = TRU
NAND (IMP,LEQ) = XOR
NAND (IMP,OR) = DENY
NAND (IMP,DENY) = OR
NAND (IMP,FLIP) = FIX
NAND (IMP,NIF) = IF
NAND (IMP,NTRU) = TRU
NAND (IMP,AND) = NAND
NAND (IMP,NIMP) = TRU
NAND (IMP,XOR) = IF
NAND (IMP,IMP) = NIMP
NAND (IMP,NAND) = FIX
NAND (IMP,TRU) = NIMP
NAND (IMP,IF) = XOR
NAND (IMP,FIX) = NAND
NAND (IMP,LET) = DENY
NAND (IMP,NOR) = OR
NAND (NAND,LEQ) = OR
NAND (NAND,OR) = LEQ
NAND (NAND,DENY) = LET
NAND (NAND,FLIP) = FIX
NAND (NAND,NIF) = IF
NAND (NAND,NTRU) = TRU
NAND (NAND,AND) = TRU
NAND (NAND,NIMP) = IMP
NAND (NAND,XOR) = LEQ
NAND (NAND,IMP) = FIX
NAND (NAND,NAND) = AND
NAND (NAND,TRU) = AND
NAND (NAND,IF) = LET
NAND (NAND,FIX) = IMP
NAND (NAND,LET) = IF
NAND (NAND,NOR) = OR
NAND (TRU,LEQ) = XOR
NAND (TRU,OR) = NOR
NAND (TRU,DENY) = LET
NAND (TRU,FLIP) = FIX
NAND (TRU,NIF) = IF
NAND (TRU,NTRU) = TRU
NAND (TRU,AND) = NAND
NAND (TRU,NIMP) = IMP
NAND (TRU,XOR) = LEQ
NAND (TRU,IMP) = NIMP
NAND (TRU,NAND) = AND
NAND (TRU,TRU) = NTRU
NAND (TRU,IF) = NIF
NAND (TRU,FIX) = FLIP
NAND (TRU,LET) = DENY
NAND (TRU,NOR) = OR
NAND (IF,LEQ) = XOR
NAND (IF,OR) = FLIP
NAND (IF,DENY) = LET
NAND (IF,FLIP) = OR
NAND (IF,NIF) = TRU
NAND (IF,NTRU) = TRU
NAND (IF,AND) = NAND
NAND (IF,NIMP) = IMP
NAND (IF,XOR) = IMP
NAND (IF,IMP) = XOR
NAND (IF,NAND) = LET
NAND (IF,TRU) = NIF
NAND (IF,IF) = NIF
NAND (IF,FIX) = FLIP
NAND (IF,LET) = NAND
NAND (IF,NOR) = OR
NAND (FIX,LEQ) = NAND
NAND (FIX,OR) = FLIP
NAND (FIX,DENY) = IMP
NAND (FIX,FLIP) = TRU
NAND (FIX,NIF) = TRU
NAND (FIX,NTRU) = TRU
NAND (FIX,AND) = NAND
NAND (FIX,NIMP) = IMP
NAND (FIX,XOR) = IMP
NAND (FIX,IMP) = NAND
NAND (FIX,NAND) = IMP
NAND (FIX,TRU) = FLIP
NAND (FIX,IF) = FLIP
NAND (FIX,FIX) = FLIP
NAND (FIX,LET) = NAND
NAND (FIX,NOR) = TRU
NAND (LET,LEQ) = NAND
NAND (LET,OR) = DENY
NAND (LET,DENY) = TRU
NAND (LET,FLIP) = IF
NAND (LET,NIF) = IF
NAND (LET,NTRU) = TRU
NAND (LET,AND) = NAND
NAND (LET,NIMP) = TRU
NAND (LET,XOR) = IF
NAND (LET,IMP) = DENY
NAND (LET,NAND) = IF
NAND (LET,TRU) = DENY
NAND (LET,IF) = NAND
NAND (LET,FIX) = NAND
NAND (LET,LET) = DENY
NAND (LET,NOR) = TRU
NAND (NOR,LEQ) = OR
NAND (NOR,OR) = TRU
NAND (NOR,DENY) = OR
NAND (NOR,FLIP) = OR
NAND (NOR,NIF) = TRU
NAND (NOR,NTRU) = TRU
NAND (NOR,AND) = TRU
NAND (NOR,NIMP) = TRU
NAND (NOR,XOR) = TRU
NAND (NOR,IMP) = OR
NAND (NOR,NAND) = OR
NAND (NOR,TRU) = OR
NAND (NOR,IF) = OR
NAND (NOR,FIX) = TRU
NAND (NOR,LET) = TRU
NAND (NOR,NOR) = OR
TRU (LEQ,LEQ) = TRU
TRU (LEQ,OR) = TRU
TRU (LEQ,DENY) = TRU
TRU (LEQ,FLIP) = TRU
TRU (LEQ,NIF) = TRU
TRU (LEQ,NTRU) = TRU
TRU (LEQ,AND) = TRU
TRU (LEQ,NIMP) = TRU
TRU (LEQ,XOR) = TRU
TRU (LEQ,IMP) = TRU
TRU (LEQ,NAND) = TRU
TRU (LEQ,TRU) = TRU
TRU (LEQ,IF) = TRU
TRU (LEQ,FIX) = TRU
TRU (LEQ,LET) = TRU
TRU (LEQ,NOR) = TRU
TRU (OR,LEQ) = TRU
TRU (OR,OR) = TRU
TRU (OR,DENY) = TRU
TRU (OR,FLIP) = TRU
TRU (OR,NIF) = TRU
TRU (OR,NTRU) = TRU
TRU (OR,AND) = TRU
TRU (OR,NIMP) = TRU
TRU (OR,XOR) = TRU
TRU (OR,IMP) = TRU
TRU (OR,NAND) = TRU
TRU (OR,TRU) = TRU
TRU (OR,IF) = TRU
TRU (OR,FIX) = TRU
TRU (OR,LET) = TRU
TRU (OR,NOR) = TRU
TRU (DENY,LEQ) = TRU
TRU (DENY,OR) = TRU
TRU (DENY,DENY) = TRU
TRU (DENY,FLIP) = TRU
TRU (DENY,NIF) = TRU
TRU (DENY,NTRU) = TRU
TRU (DENY,AND) = TRU
TRU (DENY,NIMP) = TRU
TRU (DENY,XOR) = TRU
TRU (DENY,IMP) = TRU
TRU (DENY,NAND) = TRU
TRU (DENY,TRU) = TRU
TRU (DENY,IF) = TRU
TRU (DENY,FIX) = TRU
TRU (DENY,LET) = TRU
TRU (DENY,NOR) = TRU
TRU (FLIP,LEQ) = TRU
TRU (FLIP,OR) = TRU
TRU (FLIP,DENY) = TRU
TRU (FLIP,FLIP) = TRU
TRU (FLIP,NIF) = TRU
TRU (FLIP,NTRU) = TRU
TRU (FLIP,AND) = TRU
TRU (FLIP,NIMP) = TRU
TRU (FLIP,XOR) = TRU
TRU (FLIP,IMP) = TRU
TRU (FLIP,NAND) = TRU
TRU (FLIP,TRU) = TRU
TRU (FLIP,IF) = TRU
TRU (FLIP,FIX) = TRU
TRU (FLIP,LET) = TRU
TRU (FLIP,NOR) = TRU
TRU (NIF,LEQ) = TRU
TRU (NIF,OR) = TRU
TRU (NIF,DENY) = TRU
TRU (NIF,FLIP) = TRU
TRU (NIF,NIF) = TRU
TRU (NIF,NTRU) = TRU
TRU (NIF,AND) = TRU
TRU (NIF,NIMP) = TRU
TRU (NIF,XOR) = TRU
TRU (NIF,IMP) = TRU
TRU (NIF,NAND) = TRU
TRU (NIF,TRU) = TRU
TRU (NIF,IF) = TRU
TRU (NIF,FIX) = TRU
TRU (NIF,LET) = TRU
TRU (NIF,NOR) = TRU
TRU (NTRU,LEQ) = TRU
TRU (NTRU,OR) = TRU
TRU (NTRU,DENY) = TRU
TRU (NTRU,FLIP) = TRU
TRU (NTRU,NIF) = TRU
TRU (NTRU,NTRU) = TRU
TRU (NTRU,AND) = TRU
TRU (NTRU,NIMP) = TRU
TRU (NTRU,XOR) = TRU
TRU (NTRU,IMP) = TRU
TRU (NTRU,NAND) = TRU
TRU (NTRU,TRU) = TRU
TRU (NTRU,IF) = TRU
TRU (NTRU,FIX) = TRU
TRU (NTRU,LET) = TRU
TRU (NTRU,NOR) = TRU
TRU (AND,LEQ) = TRU
TRU (AND,OR) = TRU
TRU (AND,DENY) = TRU
TRU (AND,FLIP) = TRU
TRU (AND,NIF) = TRU
TRU (AND,NTRU) = TRU
TRU (AND,AND) = TRU
TRU (AND,NIMP) = TRU
TRU (AND,XOR) = TRU
TRU (AND,IMP) = TRU
TRU (AND,NAND) = TRU
TRU (AND,TRU) = TRU
TRU (AND,IF) = TRU
TRU (AND,FIX) = TRU
TRU (AND,LET) = TRU
TRU (AND,NOR) = TRU
TRU (NIMP,LEQ) = TRU
TRU (NIMP,OR) = TRU
TRU (NIMP,DENY) = TRU
TRU (NIMP,FLIP) = TRU
TRU (NIMP,NIF) = TRU
TRU (NIMP,NTRU) = TRU
TRU (NIMP,AND) = TRU
TRU (NIMP,NIMP) = TRU
TRU (NIMP,XOR) = TRU
TRU (NIMP,IMP) = TRU
TRU (NIMP,NAND) = TRU
TRU (NIMP,TRU) = TRU
TRU (NIMP,IF) = TRU
TRU (NIMP,FIX) = TRU
TRU (NIMP,LET) = TRU
TRU (NIMP,NOR) = TRU
TRU (XOR,LEQ) = TRU
TRU (XOR,OR) = TRU
TRU (XOR,DENY) = TRU
TRU (XOR,FLIP) = TRU
TRU (XOR,NIF) = TRU
TRU (XOR,NTRU) = TRU
TRU (XOR,AND) = TRU
TRU (XOR,NIMP) = TRU
TRU (XOR,XOR) = TRU
TRU (XOR,IMP) = TRU
TRU (XOR,NAND) = TRU
TRU (XOR,TRU) = TRU
TRU (XOR,IF) = TRU
TRU (XOR,FIX) = TRU
TRU (XOR,LET) = TRU
TRU (XOR,NOR) = TRU
TRU (IMP,LEQ) = TRU
TRU (IMP,OR) = TRU
TRU (IMP,DENY) = TRU
TRU (IMP,FLIP) = TRU
TRU (IMP,NIF) = TRU
TRU (IMP,NTRU) = TRU
TRU (IMP,AND) = TRU
TRU (IMP,NIMP) = TRU
TRU (IMP,XOR) = TRU
TRU (IMP,IMP) = TRU
TRU (IMP,NAND) = TRU
TRU (IMP,TRU) = TRU
TRU (IMP,IF) = TRU
TRU (IMP,FIX) = TRU
TRU (IMP,LET) = TRU
TRU (IMP,NOR) = TRU
TRU (NAND,LEQ) = TRU
TRU (NAND,OR) = TRU
TRU (NAND,DENY) = TRU
TRU (NAND,FLIP) = TRU
TRU (NAND,NIF) = TRU
TRU (NAND,NTRU) = TRU
TRU (NAND,AND) = TRU
TRU (NAND,NIMP) = TRU
TRU (NAND,XOR) = TRU
TRU (NAND,IMP) = TRU
TRU (NAND,NAND) = TRU
TRU (NAND,TRU) = TRU
TRU (NAND,IF) = TRU
TRU (NAND,FIX) = TRU
TRU (NAND,LET) = TRU
TRU (NAND,NOR) = TRU
TRU (TRU,LEQ) = TRU
TRU (TRU,OR) = TRU
TRU (TRU,DENY) = TRU
TRU (TRU,FLIP) = TRU
TRU (TRU,NIF) = TRU
TRU (TRU,NTRU) = TRU
TRU (TRU,AND) = TRU
TRU (TRU,NIMP) = TRU
TRU (TRU,XOR) = TRU
TRU (TRU,IMP) = TRU
TRU (TRU,NAND) = TRU
TRU (TRU,TRU) = TRU
TRU (TRU,IF) = TRU
TRU (TRU,FIX) = TRU
TRU (TRU,LET) = TRU
TRU (TRU,NOR) = TRU
TRU (IF,LEQ) = TRU
TRU (IF,OR) = TRU
TRU (IF,DENY) = TRU
TRU (IF,FLIP) = TRU
TRU (IF,NIF) = TRU
TRU (IF,NTRU) = TRU
TRU (IF,AND) = TRU
TRU (IF,NIMP) = TRU
TRU (IF,XOR) = TRU
TRU (IF,IMP) = TRU
TRU (IF,NAND) = TRU
TRU (IF,TRU) = TRU
TRU (IF,IF) = TRU
TRU (IF,FIX) = TRU
TRU (IF,LET) = TRU
TRU (IF,NOR) = TRU
TRU (FIX,LEQ) = TRU
TRU (FIX,OR) = TRU
TRU (FIX,DENY) = TRU
TRU (FIX,FLIP) = TRU
TRU (FIX,NIF) = TRU
TRU (FIX,NTRU) = TRU
TRU (FIX,AND) = TRU
TRU (FIX,NIMP) = TRU
TRU (FIX,XOR) = TRU
TRU (FIX,IMP) = TRU
TRU (FIX,NAND) = TRU
TRU (FIX,TRU) = TRU
TRU (FIX,IF) = TRU
TRU (FIX,FIX) = TRU
TRU (FIX,LET) = TRU
TRU (FIX,NOR) = TRU
TRU (LET,LEQ) = TRU
TRU (LET,OR) = TRU
TRU (LET,DENY) = TRU
TRU (LET,FLIP) = TRU
TRU (LET,NIF) = TRU
TRU (LET,NTRU) = TRU
TRU (LET,AND) = TRU
TRU (LET,NIMP) = TRU
TRU (LET,XOR) = TRU
TRU (LET,IMP) = TRU
TRU (LET,NAND) = TRU
TRU (LET,TRU) = TRU
TRU (LET,IF) = TRU
TRU (LET,FIX) = TRU
TRU (LET,LET) = TRU
TRU (LET,NOR) = TRU
TRU (NOR,LEQ) = TRU
TRU (NOR,OR) = TRU
TRU (NOR,DENY) = TRU
TRU (NOR,FLIP) = TRU
TRU (NOR,NIF) = TRU
TRU (NOR,NTRU) = TRU
TRU (NOR,AND) = TRU
TRU (NOR,NIMP) = TRU
TRU (NOR,XOR) = TRU
TRU (NOR,IMP) = TRU
TRU (NOR,NAND) = TRU
TRU (NOR,TRU) = TRU
TRU (NOR,IF) = TRU
TRU (NOR,FIX) = TRU
TRU (NOR,LET) = TRU
TRU (NOR,NOR) = TRU
IF (LEQ,LEQ) = TRU
IF (LEQ,OR) = LEQ
IF (LEQ,DENY) = IMP
IF (LEQ,FLIP) = IF
IF (LEQ,NIF) = IF
IF (LEQ,NTRU) = TRU
IF (LEQ,AND) = TRU
IF (LEQ,NIMP) = IMP
IF (LEQ,XOR) = LEQ
IF (LEQ,IMP) = IF
IF (LEQ,NAND) = LEQ
IF (LEQ,TRU) = LEQ
IF (LEQ,IF) = IMP
IF (LEQ,FIX) = IMP
IF (LEQ,LET) = IF
IF (LEQ,NOR) = TRU
IF (OR,LEQ) = OR
IF (OR,OR) = TRU
IF (OR,DENY) = OR
IF (OR,FLIP) = OR
IF (OR,NIF) = TRU
IF (OR,NTRU) = TRU
IF (OR,AND) = TRU
IF (OR,NIMP) = TRU
IF (OR,XOR) = TRU
IF (OR,IMP) = OR
IF (OR,NAND) = OR
IF (OR,TRU) = OR
IF (OR,IF) = OR
IF (OR,FIX) = TRU
IF (OR,LET) = TRU
IF (OR,NOR) = OR
IF (DENY,LEQ) = NAND
IF (DENY,OR) = DENY
IF (DENY,DENY) = TRU
IF (DENY,FLIP) = IF
IF (DENY,NIF) = IF
IF (DENY,NTRU) = TRU
IF (DENY,AND) = NAND
IF (DENY,NIMP) = TRU
IF (DENY,XOR) = IF
IF (DENY,IMP) = DENY
IF (DENY,NAND) = IF
IF (DENY,TRU) = DENY
IF (DENY,IF) = NAND
IF (DENY,FIX) = NAND
IF (DENY,LET) = DENY
IF (DENY,NOR) = TRU
IF (FLIP,LEQ) = NAND
IF (FLIP,OR) = FLIP
IF (FLIP,DENY) = IMP
IF (FLIP,FLIP) = TRU
IF (FLIP,NIF) = TRU
IF (FLIP,NTRU) = TRU
IF (FLIP,AND) = NAND
IF (FLIP,NIMP) = IMP
IF (FLIP,XOR) = IMP
IF (FLIP,IMP) = NAND
IF (FLIP,NAND) = IMP
IF (FLIP,TRU) = FLIP
IF (FLIP,IF) = FLIP
IF (FLIP,FIX) = FLIP
IF (FLIP,LET) = NAND
IF (FLIP,NOR) = TRU
IF (NIF,LEQ) = XOR
IF (NIF,OR) = FLIP
IF (NIF,DENY) = LET
IF (NIF,FLIP) = OR
IF (NIF,NIF) = TRU
IF (NIF,NTRU) = TRU
IF (NIF,AND) = NAND
IF (NIF,NIMP) = IMP
IF (NIF,XOR) = IMP
IF (NIF,IMP) = XOR
IF (NIF,NAND) = LET
IF (NIF,TRU) = NIF
IF (NIF,IF) = NIF
IF (NIF,FIX) = FLIP
IF (NIF,LET) = NAND
IF (NIF,NOR) = OR
IF (NTRU,LEQ) = XOR
IF (NTRU,OR) = NOR
IF (NTRU,DENY) = LET
IF (NTRU,FLIP) = FIX
IF (NTRU,NIF) = IF
IF (NTRU,NTRU) = TRU
IF (NTRU,AND) = NAND
IF (NTRU,NIMP) = IMP
IF (NTRU,XOR) = LEQ
IF (NTRU,IMP) = NIMP
IF (NTRU,NAND) = AND
IF (NTRU,TRU) = NTRU
IF (NTRU,IF) = NIF
IF (NTRU,FIX) = FLIP
IF (NTRU,LET) = DENY
IF (NTRU,NOR) = OR
IF (AND,LEQ) = OR
IF (AND,OR) = LEQ
IF (AND,DENY) = LET
IF (AND,FLIP) = FIX
IF (AND,NIF) = IF
IF (AND,NTRU) = TRU
IF (AND,AND) = TRU
IF (AND,NIMP) = IMP
IF (AND,XOR) = LEQ
IF (AND,IMP) = FIX
IF (AND,NAND) = AND
IF (AND,TRU) = AND
IF (AND,IF) = LET
IF (AND,FIX) = IMP
IF (AND,LET) = IF
IF (AND,NOR) = OR
IF (NIMP,LEQ) = XOR
IF (NIMP,OR) = DENY
IF (NIMP,DENY) = OR
IF (NIMP,FLIP) = FIX
IF (NIMP,NIF) = IF
IF (NIMP,NTRU) = TRU
IF (NIMP,AND) = NAND
IF (NIMP,NIMP) = TRU
IF (NIMP,XOR) = IF
IF (NIMP,IMP) = NIMP
IF (NIMP,NAND) = FIX
IF (NIMP,TRU) = NIMP
IF (NIMP,IF) = XOR
IF (NIMP,FIX) = NAND
IF (NIMP,LET) = DENY
IF (NIMP,NOR) = OR
IF (XOR,LEQ) = XOR
IF (XOR,OR) = NAND
IF (XOR,DENY) = OR
IF (XOR,FLIP) = OR
IF (XOR,NIF) = TRU
IF (XOR,NTRU) = TRU
IF (XOR,AND) = NAND
IF (XOR,NIMP) = TRU
IF (XOR,XOR) = TRU
IF (XOR,IMP) = XOR
IF (XOR,NAND) = OR
IF (XOR,TRU) = XOR
IF (XOR,IF) = XOR
IF (XOR,FIX) = NAND
IF (XOR,LET) = NAND
IF (XOR,NOR) = OR
IF (IMP,LEQ) = TRU
IF (IMP,OR) = IMP
IF (IMP,DENY) = IMP
IF (IMP,FLIP) = TRU
IF (IMP,NIF) = TRU
IF (IMP,NTRU) = TRU
IF (IMP,AND) = TRU
IF (IMP,NIMP) = IMP
IF (IMP,XOR) = IMP
IF (IMP,IMP) = TRU
IF (IMP,NAND) = IMP
IF (IMP,TRU) = IMP
IF (IMP,IF) = IMP
IF (IMP,FIX) = IMP
IF (IMP,LET) = TRU
IF (IMP,NOR) = TRU
IF (NAND,LEQ) = NAND
IF (NAND,OR) = NAND
IF (NAND,DENY) = TRU
IF (NAND,FLIP) = TRU
IF (NAND,NIF) = TRU
IF (NAND,NTRU) = TRU
IF (NAND,AND) = NAND
IF (NAND,NIMP) = TRU
IF (NAND,XOR) = TRU
IF (NAND,IMP) = NAND
IF (NAND,NAND) = TRU
IF (NAND,TRU) = NAND
IF (NAND,IF) = NAND
IF (NAND,FIX) = NAND
IF (NAND,LET) = NAND
IF (NAND,NOR) = TRU
IF (TRU,LEQ) = TRU
IF (TRU,OR) = TRU
IF (TRU,DENY) = TRU
IF (TRU,FLIP) = TRU
IF (TRU,NIF) = TRU
IF (TRU,NTRU) = TRU
IF (TRU,AND) = TRU
IF (TRU,NIMP) = TRU
IF (TRU,XOR) = TRU
IF (TRU,IMP) = TRU
IF (TRU,NAND) = TRU
IF (TRU,TRU) = TRU
IF (TRU,IF) = TRU
IF (TRU,FIX) = TRU
IF (TRU,LET) = TRU
IF (TRU,NOR) = TRU
IF (IF,LEQ) = TRU
IF (IF,OR) = IF
IF (IF,DENY) = TRU
IF (IF,FLIP) = IF
IF (IF,NIF) = IF
IF (IF,NTRU) = TRU
IF (IF,AND) = TRU
IF (IF,NIMP) = TRU
IF (IF,XOR) = IF
IF (IF,IMP) = IF
IF (IF,NAND) = IF
IF (IF,TRU) = IF
IF (IF,IF) = TRU
IF (IF,FIX) = TRU
IF (IF,LET) = IF
IF (IF,NOR) = TRU
IF (FIX,LEQ) = OR
IF (FIX,OR) = IF
IF (FIX,DENY) = OR
IF (FIX,FLIP) = FIX
IF (FIX,NIF) = IF
IF (FIX,NTRU) = TRU
IF (FIX,AND) = TRU
IF (FIX,NIMP) = TRU
IF (FIX,XOR) = IF
IF (FIX,IMP) = FIX
IF (FIX,NAND) = FIX
IF (FIX,TRU) = FIX
IF (FIX,IF) = OR
IF (FIX,FIX) = TRU
IF (FIX,LET) = IF
IF (FIX,NOR) = OR
IF (LET,LEQ) = OR
IF (LET,OR) = IMP
IF (LET,DENY) = LET
IF (LET,FLIP) = OR
IF (LET,NIF) = TRU
IF (LET,NTRU) = TRU
IF (LET,AND) = TRU
IF (LET,NIMP) = IMP
IF (LET,XOR) = IMP
IF (LET,IMP) = OR
IF (LET,NAND) = LET
IF (LET,TRU) = LET
IF (LET,IF) = LET
IF (LET,FIX) = IMP
IF (LET,LET) = TRU
IF (LET,NOR) = OR
IF (NOR,LEQ) = NAND
IF (NOR,OR) = NOR
IF (NOR,DENY) = IMP
IF (NOR,FLIP) = IF
IF (NOR,NIF) = IF
IF (NOR,NTRU) = TRU
IF (NOR,AND) = NAND
IF (NOR,NIMP) = IMP
IF (NOR,XOR) = LEQ
IF (NOR,IMP) = DENY
IF (NOR,NAND) = LEQ
IF (NOR,TRU) = NOR
IF (NOR,IF) = FLIP
IF (NOR,FIX) = FLIP
IF (NOR,LET) = DENY
IF (NOR,NOR) = TRU
FIX (LEQ,LEQ) = LEQ
FIX (LEQ,OR) = LEQ
FIX (LEQ,DENY) = LEQ
FIX (LEQ,FLIP) = LEQ
FIX (LEQ,NIF) = LEQ
FIX (LEQ,NTRU) = LEQ
FIX (LEQ,AND) = LEQ
FIX (LEQ,NIMP) = LEQ
FIX (LEQ,XOR) = LEQ
FIX (LEQ,IMP) = LEQ
FIX (LEQ,NAND) = LEQ
FIX (LEQ,TRU) = LEQ
FIX (LEQ,IF) = LEQ
FIX (LEQ,FIX) = LEQ
FIX (LEQ,LET) = LEQ
FIX (LEQ,NOR) = LEQ
FIX (OR,LEQ) = OR
FIX (OR,OR) = OR
FIX (OR,DENY) = OR
FIX (OR,FLIP) = OR
FIX (OR,NIF) = OR
FIX (OR,NTRU) = OR
FIX (OR,AND) = OR
FIX (OR,NIMP) = OR
FIX (OR,XOR) = OR
FIX (OR,IMP) = OR
FIX (OR,NAND) = OR
FIX (OR,TRU) = OR
FIX (OR,IF) = OR
FIX (OR,FIX) = OR
FIX (OR,LET) = OR
FIX (OR,NOR) = OR
FIX (DENY,LEQ) = DENY
FIX (DENY,OR) = DENY
FIX (DENY,DENY) = DENY
FIX (DENY,FLIP) = DENY
FIX (DENY,NIF) = DENY
FIX (DENY,NTRU) = DENY
FIX (DENY,AND) = DENY
FIX (DENY,NIMP) = DENY
FIX (DENY,XOR) = DENY
FIX (DENY,IMP) = DENY
FIX (DENY,NAND) = DENY
FIX (DENY,TRU) = DENY
FIX (DENY,IF) = DENY
FIX (DENY,FIX) = DENY
FIX (DENY,LET) = DENY
FIX (DENY,NOR) = DENY
FIX (FLIP,LEQ) = FLIP
FIX (FLIP,OR) = FLIP
FIX (FLIP,DENY) = FLIP
FIX (FLIP,FLIP) = FLIP
FIX (FLIP,NIF) = FLIP
FIX (FLIP,NTRU) = FLIP
FIX (FLIP,AND) = FLIP
FIX (FLIP,NIMP) = FLIP
FIX (FLIP,XOR) = FLIP
FIX (FLIP,IMP) = FLIP
FIX (FLIP,NAND) = FLIP
FIX (FLIP,TRU) = FLIP
FIX (FLIP,IF) = FLIP
FIX (FLIP,FIX) = FLIP
FIX (FLIP,LET) = FLIP
FIX (FLIP,NOR) = FLIP
FIX (NIF,LEQ) = NIF
FIX (NIF,OR) = NIF
FIX (NIF,DENY) = NIF
FIX (NIF,FLIP) = NIF
FIX (NIF,NIF) = NIF
FIX (NIF,NTRU) = NIF
FIX (NIF,AND) = NIF
FIX (NIF,NIMP) = NIF
FIX (NIF,XOR) = NIF
FIX (NIF,IMP) = NIF
FIX (NIF,NAND) = NIF
FIX (NIF,TRU) = NIF
FIX (NIF,IF) = NIF
FIX (NIF,FIX) = NIF
FIX (NIF,LET) = NIF
FIX (NIF,NOR) = NIF
FIX (NTRU,LEQ) = NTRU
FIX (NTRU,OR) = NTRU
FIX (NTRU,DENY) = NTRU
FIX (NTRU,FLIP) = NTRU
FIX (NTRU,NIF) = NTRU
FIX (NTRU,NTRU) = NTRU
FIX (NTRU,AND) = NTRU
FIX (NTRU,NIMP) = NTRU
FIX (NTRU,XOR) = NTRU
FIX (NTRU,IMP) = NTRU
FIX (NTRU,NAND) = NTRU
FIX (NTRU,TRU) = NTRU
FIX (NTRU,IF) = NTRU
FIX (NTRU,FIX) = NTRU
FIX (NTRU,LET) = NTRU
FIX (NTRU,NOR) = NTRU
FIX (AND,LEQ) = AND
FIX (AND,OR) = AND
FIX (AND,DENY) = AND
FIX (AND,FLIP) = AND
FIX (AND,NIF) = AND
FIX (AND,NTRU) = AND
FIX (AND,AND) = AND
FIX (AND,NIMP) = AND
FIX (AND,XOR) = AND
FIX (AND,IMP) = AND
FIX (AND,NAND) = AND
FIX (AND,TRU) = AND
FIX (AND,IF) = AND
FIX (AND,FIX) = AND
FIX (AND,LET) = AND
FIX (AND,NOR) = AND
FIX (NIMP,LEQ) = NIMP
FIX (NIMP,OR) = NIMP
FIX (NIMP,DENY) = NIMP
FIX (NIMP,FLIP) = NIMP
FIX (NIMP,NIF) = NIMP
FIX (NIMP,NTRU) = NIMP
FIX (NIMP,AND) = NIMP
FIX (NIMP,NIMP) = NIMP
FIX (NIMP,XOR) = NIMP
FIX (NIMP,IMP) = NIMP
FIX (NIMP,NAND) = NIMP
FIX (NIMP,TRU) = NIMP
FIX (NIMP,IF) = NIMP
FIX (NIMP,FIX) = NIMP
FIX (NIMP,LET) = NIMP
FIX (NIMP,NOR) = NIMP
FIX (XOR,LEQ) = XOR
FIX (XOR,OR) = XOR
FIX (XOR,DENY) = XOR
FIX (XOR,FLIP) = XOR
FIX (XOR,NIF) = XOR
FIX (XOR,NTRU) = XOR
FIX (XOR,AND) = XOR
FIX (XOR,NIMP) = XOR
FIX (XOR,XOR) = XOR
FIX (XOR,IMP) = XOR
FIX (XOR,NAND) = XOR
FIX (XOR,TRU) = XOR
FIX (XOR,IF) = XOR
FIX (XOR,FIX) = XOR
FIX (XOR,LET) = XOR
FIX (XOR,NOR) = XOR
FIX (IMP,LEQ) = IMP
FIX (IMP,OR) = IMP
FIX (IMP,DENY) = IMP
FIX (IMP,FLIP) = IMP
FIX (IMP,NIF) = IMP
FIX (IMP,NTRU) = IMP
FIX (IMP,AND) = IMP
FIX (IMP,NIMP) = IMP
FIX (IMP,XOR) = IMP
FIX (IMP,IMP) = IMP
FIX (IMP,NAND) = IMP
FIX (IMP,TRU) = IMP
FIX (IMP,IF) = IMP
FIX (IMP,FIX) = IMP
FIX (IMP,LET) = IMP
FIX (IMP,NOR) = IMP
FIX (NAND,LEQ) = NAND
FIX (NAND,OR) = NAND
FIX (NAND,DENY) = NAND
FIX (NAND,FLIP) = NAND
FIX (NAND,NIF) = NAND
FIX (NAND,NTRU) = NAND
FIX (NAND,AND) = NAND
FIX (NAND,NIMP) = NAND
FIX (NAND,XOR) = NAND
FIX (NAND,IMP) = NAND
FIX (NAND,NAND) = NAND
FIX (NAND,TRU) = NAND
FIX (NAND,IF) = NAND
FIX (NAND,FIX) = NAND
FIX (NAND,LET) = NAND
FIX (NAND,NOR) = NAND
FIX (TRU,LEQ) = TRU
FIX (TRU,OR) = TRU
FIX (TRU,DENY) = TRU
FIX (TRU,FLIP) = TRU
FIX (TRU,NIF) = TRU
FIX (TRU,NTRU) = TRU
FIX (TRU,AND) = TRU
FIX (TRU,NIMP) = TRU
FIX (TRU,XOR) = TRU
FIX (TRU,IMP) = TRU
FIX (TRU,NAND) = TRU
FIX (TRU,TRU) = TRU
FIX (TRU,IF) = TRU
FIX (TRU,FIX) = TRU
FIX (TRU,LET) = TRU
FIX (TRU,NOR) = TRU
FIX (IF,LEQ) = IF
FIX (IF,OR) = IF
FIX (IF,DENY) = IF
FIX (IF,FLIP) = IF
FIX (IF,NIF) = IF
FIX (IF,NTRU) = IF
FIX (IF,AND) = IF
FIX (IF,NIMP) = IF
FIX (IF,XOR) = IF
FIX (IF,IMP) = IF
FIX (IF,NAND) = IF
FIX (IF,TRU) = IF
FIX (IF,IF) = IF
FIX (IF,FIX) = IF
FIX (IF,LET) = IF
FIX (IF,NOR) = IF
FIX (FIX,LEQ) = FIX
FIX (FIX,OR) = FIX
FIX (FIX,DENY) = FIX
FIX (FIX,FLIP) = FIX
FIX (FIX,NIF) = FIX
FIX (FIX,NTRU) = FIX
FIX (FIX,AND) = FIX
FIX (FIX,NIMP) = FIX
FIX (FIX,XOR) = FIX
FIX (FIX,IMP) = FIX
FIX (FIX,NAND) = FIX
FIX (FIX,TRU) = FIX
FIX (FIX,IF) = FIX
FIX (FIX,FIX) = FIX
FIX (FIX,LET) = FIX
FIX (FIX,NOR) = FIX
FIX (LET,LEQ) = LET
FIX (LET,OR) = LET
FIX (LET,DENY) = LET
FIX (LET,FLIP) = LET
FIX (LET,NIF) = LET
FIX (LET,NTRU) = LET
FIX (LET,AND) = LET
FIX (LET,NIMP) = LET
FIX (LET,XOR) = LET
FIX (LET,IMP) = LET
FIX (LET,NAND) = LET
FIX (LET,TRU) = LET
FIX (LET,IF) = LET
FIX (LET,FIX) = LET
FIX (LET,LET) = LET
FIX (LET,NOR) = LET
FIX (NOR,LEQ) = NOR
FIX (NOR,OR) = NOR
FIX (NOR,DENY) = NOR
FIX (NOR,FLIP) = NOR
FIX (NOR,NIF) = NOR
FIX (NOR,NTRU) = NOR
FIX (NOR,AND) = NOR
FIX (NOR,NIMP) = NOR
FIX (NOR,XOR) = NOR
FIX (NOR,IMP) = NOR
FIX (NOR,NAND) = NOR
FIX (NOR,TRU) = NOR
FIX (NOR,IF) = NOR
FIX (NOR,FIX) = NOR
FIX (NOR,LET) = NOR
FIX (NOR,NOR) = NOR
LET (LEQ,LEQ) = LEQ
LET (LEQ,OR) = OR
LET (LEQ,DENY) = DENY
LET (LEQ,FLIP) = FLIP
LET (LEQ,NIF) = NIF
LET (LEQ,NTRU) = NTRU
LET (LEQ,AND) = AND
LET (LEQ,NIMP) = NIMP
LET (LEQ,XOR) = XOR
LET (LEQ,IMP) = IMP
LET (LEQ,NAND) = NAND
LET (LEQ,TRU) = TRU
LET (LEQ,IF) = IF
LET (LEQ,FIX) = FIX
LET (LEQ,LET) = LET
LET (LEQ,NOR) = NOR
LET (OR,LEQ) = LEQ
LET (OR,OR) = OR
LET (OR,DENY) = DENY
LET (OR,FLIP) = FLIP
LET (OR,NIF) = NIF
LET (OR,NTRU) = NTRU
LET (OR,AND) = AND
LET (OR,NIMP) = NIMP
LET (OR,XOR) = XOR
LET (OR,IMP) = IMP
LET (OR,NAND) = NAND
LET (OR,TRU) = TRU
LET (OR,IF) = IF
LET (OR,FIX) = FIX
LET (OR,LET) = LET
LET (OR,NOR) = NOR
LET (DENY,LEQ) = LEQ
LET (DENY,OR) = OR
LET (DENY,DENY) = DENY
LET (DENY,FLIP) = FLIP
LET (DENY,NIF) = NIF
LET (DENY,NTRU) = NTRU
LET (DENY,AND) = AND
LET (DENY,NIMP) = NIMP
LET (DENY,XOR) = XOR
LET (DENY,IMP) = IMP
LET (DENY,NAND) = NAND
LET (DENY,TRU) = TRU
LET (DENY,IF) = IF
LET (DENY,FIX) = FIX
LET (DENY,LET) = LET
LET (DENY,NOR) = NOR
LET (FLIP,LEQ) = LEQ
LET (FLIP,OR) = OR
LET (FLIP,DENY) = DENY
LET (FLIP,FLIP) = FLIP
LET (FLIP,NIF) = NIF
LET (FLIP,NTRU) = NTRU
LET (FLIP,AND) = AND
LET (FLIP,NIMP) = NIMP
LET (FLIP,XOR) = XOR
LET (FLIP,IMP) = IMP
LET (FLIP,NAND) = NAND
LET (FLIP,TRU) = TRU
LET (FLIP,IF) = IF
LET (FLIP,FIX) = FIX
LET (FLIP,LET) = LET
LET (FLIP,NOR) = NOR
LET (NIF,LEQ) = LEQ
LET (NIF,OR) = OR
LET (NIF,DENY) = DENY
LET (NIF,FLIP) = FLIP
LET (NIF,NIF) = NIF
LET (NIF,NTRU) = NTRU
LET (NIF,AND) = AND
LET (NIF,NIMP) = NIMP
LET (NIF,XOR) = XOR
LET (NIF,IMP) = IMP
LET (NIF,NAND) = NAND
LET (NIF,TRU) = TRU
LET (NIF,IF) = IF
LET (NIF,FIX) = FIX
LET (NIF,LET) = LET
LET (NIF,NOR) = NOR
LET (NTRU,LEQ) = LEQ
LET (NTRU,OR) = OR
LET (NTRU,DENY) = DENY
LET (NTRU,FLIP) = FLIP
LET (NTRU,NIF) = NIF
LET (NTRU,NTRU) = NTRU
LET (NTRU,AND) = AND
LET (NTRU,NIMP) = NIMP
LET (NTRU,XOR) = XOR
LET (NTRU,IMP) = IMP
LET (NTRU,NAND) = NAND
LET (NTRU,TRU) = TRU
LET (NTRU,IF) = IF
LET (NTRU,FIX) = FIX
LET (NTRU,LET) = LET
LET (NTRU,NOR) = NOR
LET (AND,LEQ) = LEQ
LET (AND,OR) = OR
LET (AND,DENY) = DENY
LET (AND,FLIP) = FLIP
LET (AND,NIF) = NIF
LET (AND,NTRU) = NTRU
LET (AND,AND) = AND
LET (AND,NIMP) = NIMP
LET (AND,XOR) = XOR
LET (AND,IMP) = IMP
LET (AND,NAND) = NAND
LET (AND,TRU) = TRU
LET (AND,IF) = IF
LET (AND,FIX) = FIX
LET (AND,LET) = LET
LET (AND,NOR) = NOR
LET (NIMP,LEQ) = LEQ
LET (NIMP,OR) = OR
LET (NIMP,DENY) = DENY
LET (NIMP,FLIP) = FLIP
LET (NIMP,NIF) = NIF
LET (NIMP,NTRU) = NTRU
LET (NIMP,AND) = AND
LET (NIMP,NIMP) = NIMP
LET (NIMP,XOR) = XOR
LET (NIMP,IMP) = IMP
LET (NIMP,NAND) = NAND
LET (NIMP,TRU) = TRU
LET (NIMP,IF) = IF
LET (NIMP,FIX) = FIX
LET (NIMP,LET) = LET
LET (NIMP,NOR) = NOR
LET (XOR,LEQ) = LEQ
LET (XOR,OR) = OR
LET (XOR,DENY) = DENY
LET (XOR,FLIP) = FLIP
LET (XOR,NIF) = NIF
LET (XOR,NTRU) = NTRU
LET (XOR,AND) = AND
LET (XOR,NIMP) = NIMP
LET (XOR,XOR) = XOR
LET (XOR,IMP) = IMP
LET (XOR,NAND) = NAND
LET (XOR,TRU) = TRU
LET (XOR,IF) = IF
LET (XOR,FIX) = FIX
LET (XOR,LET) = LET
LET (XOR,NOR) = NOR
LET (IMP,LEQ) = LEQ
LET (IMP,OR) = OR
LET (IMP,DENY) = DENY
LET (IMP,FLIP) = FLIP
LET (IMP,NIF) = NIF
LET (IMP,NTRU) = NTRU
LET (IMP,AND) = AND
LET (IMP,NIMP) = NIMP
LET (IMP,XOR) = XOR
LET (IMP,IMP) = IMP
LET (IMP,NAND) = NAND
LET (IMP,TRU) = TRU
LET (IMP,IF) = IF
LET (IMP,FIX) = FIX
LET (IMP,LET) = LET
LET (IMP,NOR) = NOR
LET (NAND,LEQ) = LEQ
LET (NAND,OR) = OR
LET (NAND,DENY) = DENY
LET (NAND,FLIP) = FLIP
LET (NAND,NIF) = NIF
LET (NAND,NTRU) = NTRU
LET (NAND,AND) = AND
LET (NAND,NIMP) = NIMP
LET (NAND,XOR) = XOR
LET (NAND,IMP) = IMP
LET (NAND,NAND) = NAND
LET (NAND,TRU) = TRU
LET (NAND,IF) = IF
LET (NAND,FIX) = FIX
LET (NAND,LET) = LET
LET (NAND,NOR) = NOR
LET (TRU,LEQ) = LEQ
LET (TRU,OR) = OR
LET (TRU,DENY) = DENY
LET (TRU,FLIP) = FLIP
LET (TRU,NIF) = NIF
LET (TRU,NTRU) = NTRU
LET (TRU,AND) = AND
LET (TRU,NIMP) = NIMP
LET (TRU,XOR) = XOR
LET (TRU,IMP) = IMP
LET (TRU,NAND) = NAND
LET (TRU,TRU) = TRU
LET (TRU,IF) = IF
LET (TRU,FIX) = FIX
LET (TRU,LET) = LET
LET (TRU,NOR) = NOR
LET (IF,LEQ) = LEQ
LET (IF,OR) = OR
LET (IF,DENY) = DENY
LET (IF,FLIP) = FLIP
LET (IF,NIF) = NIF
LET (IF,NTRU) = NTRU
LET (IF,AND) = AND
LET (IF,NIMP) = NIMP
LET (IF,XOR) = XOR
LET (IF,IMP) = IMP
LET (IF,NAND) = NAND
LET (IF,TRU) = TRU
LET (IF,IF) = IF
LET (IF,FIX) = FIX
LET (IF,LET) = LET
LET (IF,NOR) = NOR
LET (FIX,LEQ) = LEQ
LET (FIX,OR) = OR
LET (FIX,DENY) = DENY
LET (FIX,FLIP) = FLIP
LET (FIX,NIF) = NIF
LET (FIX,NTRU) = NTRU
LET (FIX,AND) = AND
LET (FIX,NIMP) = NIMP
LET (FIX,XOR) = XOR
LET (FIX,IMP) = IMP
LET (FIX,NAND) = NAND
LET (FIX,TRU) = TRU
LET (FIX,IF) = IF
LET (FIX,FIX) = FIX
LET (FIX,LET) = LET
LET (FIX,NOR) = NOR
LET (LET,LEQ) = LEQ
LET (LET,OR) = OR
LET (LET,DENY) = DENY
LET (LET,FLIP) = FLIP
LET (LET,NIF) = NIF
LET (LET,NTRU) = NTRU
LET (LET,AND) = AND
LET (LET,NIMP) = NIMP
LET (LET,XOR) = XOR
LET (LET,IMP) = IMP
LET (LET,NAND) = NAND
LET (LET,TRU) = TRU
LET (LET,IF) = IF
LET (LET,FIX) = FIX
LET (LET,LET) = LET
LET (LET,NOR) = NOR
LET (NOR,LEQ) = LEQ
LET (NOR,OR) = OR
LET (NOR,DENY) = DENY
LET (NOR,FLIP) = FLIP
LET (NOR,NIF) = NIF
LET (NOR,NTRU) = NTRU
LET (NOR,AND) = AND
LET (NOR,NIMP) = NIMP
LET (NOR,XOR) = XOR
LET (NOR,IMP) = IMP
LET (NOR,NAND) = NAND
LET (NOR,TRU) = TRU
LET (NOR,IF) = IF
LET (NOR,FIX) = FIX
LET (NOR,LET) = LET
LET (NOR,NOR) = NOR
NOR (LEQ,LEQ) = XOR
NOR (LEQ,OR) = NTRU
NOR (LEQ,DENY) = NIF
NOR (LEQ,FLIP) = NIMP
NOR (LEQ,NIF) = NIMP
NOR (LEQ,NTRU) = XOR
NOR (LEQ,AND) = XOR
NOR (LEQ,NIMP) = NIF
NOR (LEQ,XOR) = NTRU
NOR (LEQ,IMP) = NIMP
NOR (LEQ,NAND) = NTRU
NOR (LEQ,TRU) = NTRU
NOR (LEQ,IF) = NIF
NOR (LEQ,FIX) = NIF
NOR (LEQ,LET) = NIMP
NOR (LEQ,NOR) = XOR
NOR (OR,LEQ) = NTRU
NOR (OR,OR) = NOR
NOR (OR,DENY) = NTRU
NOR (OR,FLIP) = NTRU
NOR (OR,NIF) = NOR
NOR (OR,NTRU) = NOR
NOR (OR,AND) = NOR
NOR (OR,NIMP) = NOR
NOR (OR,XOR) = NOR
NOR (OR,IMP) = NTRU
NOR (OR,NAND) = NTRU
NOR (OR,TRU) = NTRU
NOR (OR,IF) = NTRU
NOR (OR,FIX) = NOR
NOR (OR,LET) = NOR
NOR (OR,NOR) = NTRU
NOR (DENY,LEQ) = NIF
NOR (DENY,OR) = NTRU
NOR (DENY,DENY) = LET
NOR (DENY,FLIP) = AND
NOR (DENY,NIF) = AND
NOR (DENY,NTRU) = LET
NOR (DENY,AND) = NIF
NOR (DENY,NIMP) = LET
NOR (DENY,XOR) = AND
NOR (DENY,IMP) = NTRU
NOR (DENY,NAND) = AND
NOR (DENY,TRU) = NTRU
NOR (DENY,IF) = NIF
NOR (DENY,FIX) = NIF
NOR (DENY,LET) = NTRU
NOR (DENY,NOR) = LET
NOR (FLIP,LEQ) = NIMP
NOR (FLIP,OR) = NTRU
NOR (FLIP,DENY) = AND
NOR (FLIP,FLIP) = FIX
NOR (FLIP,NIF) = FIX
NOR (FLIP,NTRU) = FIX
NOR (FLIP,AND) = NIMP
NOR (FLIP,NIMP) = AND
NOR (FLIP,XOR) = AND
NOR (FLIP,IMP) = NIMP
NOR (FLIP,NAND) = AND
NOR (FLIP,TRU) = NTRU
NOR (FLIP,IF) = NTRU
NOR (FLIP,FIX) = NTRU
NOR (FLIP,LET) = NIMP
NOR (FLIP,NOR) = FIX
NOR (NIF,LEQ) = NIMP
NOR (NIF,OR) = NOR
NOR (NIF,DENY) = AND
NOR (NIF,FLIP) = FIX
NOR (NIF,NIF) = IF
NOR (NIF,NTRU) = IF
NOR (NIF,AND) = DENY
NOR (NIF,NIMP) = LEQ
NOR (NIF,XOR) = LEQ
NOR (NIF,IMP) = NIMP
NOR (NIF,NAND) = AND
NOR (NIF,TRU) = NTRU
NOR (NIF,IF) = NTRU
NOR (NIF,FIX) = NOR
NOR (NIF,LET) = DENY
NOR (NIF,NOR) = FIX
NOR (NTRU,LEQ) = XOR
NOR (NTRU,OR) = NOR
NOR (NTRU,DENY) = LET
NOR (NTRU,FLIP) = FIX
NOR (NTRU,NIF) = IF
NOR (NTRU,NTRU) = TRU
NOR (NTRU,AND) = NAND
NOR (NTRU,NIMP) = IMP
NOR (NTRU,XOR) = LEQ
NOR (NTRU,IMP) = NIMP
NOR (NTRU,NAND) = AND
NOR (NTRU,TRU) = NTRU
NOR (NTRU,IF) = NIF
NOR (NTRU,FIX) = FLIP
NOR (NTRU,LET) = DENY
NOR (NTRU,NOR) = OR
NOR (AND,LEQ) = XOR
NOR (AND,OR) = NOR
NOR (AND,DENY) = NIF
NOR (AND,FLIP) = NIMP
NOR (AND,NIF) = DENY
NOR (AND,NTRU) = NAND
NOR (AND,AND) = NAND
NOR (AND,NIMP) = FLIP
NOR (AND,XOR) = NOR
NOR (AND,IMP) = NIMP
NOR (AND,NAND) = NTRU
NOR (AND,TRU) = NTRU
NOR (AND,IF) = NIF
NOR (AND,FIX) = FLIP
NOR (AND,LET) = DENY
NOR (AND,NOR) = XOR
NOR (NIMP,LEQ) = NIF
NOR (NIMP,OR) = NOR
NOR (NIMP,DENY) = LET
NOR (NIMP,FLIP) = AND
NOR (NIMP,NIF) = LEQ
NOR (NIMP,NTRU) = IMP
NOR (NIMP,AND) = FLIP
NOR (NIMP,NIMP) = IMP
NOR (NIMP,XOR) = LEQ
NOR (NIMP,IMP) = NTRU
NOR (NIMP,NAND) = AND
NOR (NIMP,TRU) = NTRU
NOR (NIMP,IF) = NIF
NOR (NIMP,FIX) = FLIP
NOR (NIMP,LET) = NOR
NOR (NIMP,NOR) = LET
NOR (XOR,LEQ) = NTRU
NOR (XOR,OR) = NOR
NOR (XOR,DENY) = AND
NOR (XOR,FLIP) = AND
NOR (XOR,NIF) = LEQ
NOR (XOR,NTRU) = LEQ
NOR (XOR,AND) = NOR
NOR (XOR,NIMP) = LEQ
NOR (XOR,XOR) = LEQ
NOR (XOR,IMP) = NTRU
NOR (XOR,NAND) = AND
NOR (XOR,TRU) = NTRU
NOR (XOR,IF) = NTRU
NOR (XOR,FIX) = NOR
NOR (XOR,LET) = NOR
NOR (XOR,NOR) = AND
NOR (IMP,LEQ) = NIMP
NOR (IMP,OR) = NTRU
NOR (IMP,DENY) = NTRU
NOR (IMP,FLIP) = NIMP
NOR (IMP,NIF) = NIMP
NOR (IMP,NTRU) = NIMP
NOR (IMP,AND) = NIMP
NOR (IMP,NIMP) = NTRU
NOR (IMP,XOR) = NTRU
NOR (IMP,IMP) = NIMP
NOR (IMP,NAND) = NTRU
NOR (IMP,TRU) = NTRU
NOR (IMP,IF) = NTRU
NOR (IMP,FIX) = NTRU
NOR (IMP,LET) = NIMP
NOR (IMP,NOR) = NIMP
NOR (NAND,LEQ) = NTRU
NOR (NAND,OR) = NTRU
NOR (NAND,DENY) = AND
NOR (NAND,FLIP) = AND
NOR (NAND,NIF) = AND
NOR (NAND,NTRU) = AND
NOR (NAND,AND) = NTRU
NOR (NAND,NIMP) = AND
NOR (NAND,XOR) = AND
NOR (NAND,IMP) = NTRU
NOR (NAND,NAND) = AND
NOR (NAND,TRU) = NTRU
NOR (NAND,IF) = NTRU
NOR (NAND,FIX) = NTRU
NOR (NAND,LET) = NTRU
NOR (NAND,NOR) = AND
NOR (TRU,LEQ) = NTRU
NOR (TRU,OR) = NTRU
NOR (TRU,DENY) = NTRU
NOR (TRU,FLIP) = NTRU
NOR (TRU,NIF) = NTRU
NOR (TRU,NTRU) = NTRU
NOR (TRU,AND) = NTRU
NOR (TRU,NIMP) = NTRU
NOR (TRU,XOR) = NTRU
NOR (TRU,IMP) = NTRU
NOR (TRU,NAND) = NTRU
NOR (TRU,TRU) = NTRU
NOR (TRU,IF) = NTRU
NOR (TRU,FIX) = NTRU
NOR (TRU,LET) = NTRU
NOR (TRU,NOR) = NTRU
NOR (IF,LEQ) = NIF
NOR (IF,OR) = NTRU
NOR (IF,DENY) = NIF
NOR (IF,FLIP) = NTRU
NOR (IF,NIF) = NTRU
NOR (IF,NTRU) = NIF
NOR (IF,AND) = NIF
NOR (IF,NIMP) = NIF
NOR (IF,XOR) = NTRU
NOR (IF,IMP) = NTRU
NOR (IF,NAND) = NTRU
NOR (IF,TRU) = NTRU
NOR (IF,IF) = NIF
NOR (IF,FIX) = NIF
NOR (IF,LET) = NTRU
NOR (IF,NOR) = NIF
NOR (FIX,LEQ) = NIF
NOR (FIX,OR) = NOR
NOR (FIX,DENY) = NIF
NOR (FIX,FLIP) = NTRU
NOR (FIX,NIF) = NOR
NOR (FIX,NTRU) = FLIP
NOR (FIX,AND) = FLIP
NOR (FIX,NIMP) = FLIP
NOR (FIX,XOR) = NOR
NOR (FIX,IMP) = NTRU
NOR (FIX,NAND) = NTRU
NOR (FIX,TRU) = NTRU
NOR (FIX,IF) = NIF
NOR (FIX,FIX) = FLIP
NOR (FIX,LET) = NOR
NOR (FIX,NOR) = NIF
NOR (LET,LEQ) = NIMP
NOR (LET,OR) = NOR
NOR (LET,DENY) = NTRU
NOR (LET,FLIP) = NIMP
NOR (LET,NIF) = DENY
NOR (LET,NTRU) = DENY
NOR (LET,AND) = DENY
NOR (LET,NIMP) = NOR
NOR (LET,XOR) = NOR
NOR (LET,IMP) = NIMP
NOR (LET,NAND) = NTRU
NOR (LET,TRU) = NTRU
NOR (LET,IF) = NTRU
NOR (LET,FIX) = NOR
NOR (LET,LET) = DENY
NOR (LET,NOR) = NIMP
NOR (NOR,LEQ) = XOR
NOR (NOR,OR) = NTRU
NOR (NOR,DENY) = LET
NOR (NOR,FLIP) = FIX
NOR (NOR,NIF) = FIX
NOR (NOR,NTRU) = OR
NOR (NOR,AND) = XOR
NOR (NOR,NIMP) = LET
NOR (NOR,XOR) = AND
NOR (NOR,IMP) = NIMP
NOR (NOR,NAND) = AND
NOR (NOR,TRU) = NTRU
NOR (NOR,IF) = NIF
NOR (NOR,FIX) = NIF
NOR (NOR,LET) = NIMP
NOR (NOR,NOR) = OR

[Graham Cooper]

Only some of these reduce

LHS has 4 arguments = RHS has 2

PREDICATE (16)
/ \
LEFT ARG RIGHT ARG
(16) (16)

--- P ----- LA -----------RA
if( and( and( A,B ) , and( C,D ) ) , ___ ).
if( and( and( A,B ) , or( C,D )) , ___ ).
...

e.g.
if( and(if(A,B),if(B,C)) , if(A,C) ).
if( and(or(A,B),if(B,C)) , or(A,C) ).
if( and(and(A,B),if(B,C)) , and(A,C) ).

e.g. line 1 is A->B ^ B->C --> A->C
e.g. line 2 is AvB ^ ~BvC --> AvC

Herc

[fom]

On 12/7/2012 3:32 AM, Graham Cooper wrote:
> On Dec 7, 5:25 pm, fom <fomJ...@nyms.net> wrote:

<snip>

>> NOR (NOR,NOR) = OR


((p NOR q) NOR (p NOR q)

T..F..T...T...T..F..T
T..F..F...T...T..F..F
F..T..F...F...F..T..F
F..F..T...T...F..F..T


p q | p OR q
------|--------
T T | T
T F | T
F F | F
F T | T

[Graham Cooper]

On Dec 7, 8:24 pm, fom <fomJ...@nyms.net> wrote:
> >>
> >> NOR (NOR,NOR) = OR
>
> ((p NOR q) NOR (p NOR q)
>
>    T..F..T...T...T..F..T
>    T..F..F...T...T..F..F
>    F..T..F...F...F..T..F
>    F..F..T...T...F..F..T
>
>   p  q | p OR q
> ------|--------
>   T  T |   T
>   T  F |   T
>   F  F |   F
>   F  T |   T
>

OK, here are the 16 predicates..



p(n,A,B,_)

p(1,0,0,0).
p(1,0,1,0).
p(1,1,0,0).
p(1,1,1,0).

p(2,0,0,0). AND
p(2,0,1,0).
p(2,1,0,0).
p(2,1,1,1).

p(3,0,0,0).
p(3,0,1,0).
p(3,1,0,1).
p(3,1,1,0).

p(4,0,0,0).
p(4,0,1,0).
p(4,1,0,1).
p(4,1,1,1).

p(5,0,0,0).
p(5,0,1,1).
p(5,1,0,0).
p(5,1,1,0).

p(6,0,0,0).
p(6,0,1,1).
p(6,1,0,0).
p(6,1,1,1).

p(7,0,0,0).
p(7,0,1,1).
p(7,1,0,1).
p(7,1,1,0).

p(8,0,0,0). OR
p(8,0,1,1).
p(8,1,0,1).
p(8,1,1,1).

p(9,0,0,1).
p(9,0,1,0).
p(9,1,0,0).
p(9,1,1,0).

p(10,0,0,1).
p(10,0,1,0).
p(10,1,0,0).
p(10,1,1,1).

p(11,0,0,1).
p(11,0,1,0).
p(11,1,0,1).
p(11,1,1,0).

p(12,0,0,1).
p(12,0,1,0).
p(12,1,0,1).
p(12,1,1,1).

p(13,0,0,1).
p(13,0,1,1).
p(13,1,0,0).
p(13,1,1,0).

p(14,0,0,1).
p(14,0,1,1).
p(14,1,0,0).
p(14,1,1,1).

p(15,0,0,1).
p(15,0,1,1).
p(15,1,0,1).
p(15,1,1,0).

p(16,0,0,1).
p(16,0,1,1).
p(16,1,0,1).
p(16,1,1,1).



I might run a program

pn(pm,ps)

on all 4 inputs and check the result
against the 4 inputs, if there is a duplicate
it can be reduced.

e.g.

and(if(A,B),if(B,C))

the result is the same as

if(A,C)

so I could detect B is eliminated
and a reduction exists.


Herc

[fom]

yes

that is how the list was generated

but, the purpose of the list is a step
required to transform uninterpreted
symbols purported to be constants
into symbols interpretable as
functions

the axioms assert the identity
statements that establish that
situation

take a quick look somewhere at
universal algebras and varieties
(or even equational classes since
that is how Birkhoff introduced
the notion)

the compositionality underlying
the generation of wffs is a property
that can be expressed without
truth tables

but, the ideas lie with Church and
Curry, since it Church used it to
introduce the lambda calculus and
Curry used it to describe logistic
systems built on applicative systems