Date: Dec 7, 2012 2:25 AM Author: fom Subject: fom - 03 - connectivity algebra

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