Search All of the Math Forum:

Views expressed in these public forums are not endorsed by NCTM or The Math Forum.

Topic: fom - 03 - connectivity algebra
Replies: 4   Last Post: Dec 7, 2012 5:30 PM

 Search Thread: Advanced Search

 Messages: [ Previous | Next ]
 Graham Cooper Posts: 4,495 Registered: 5/20/10
Re: fom - 03 - connectivity algebra
Posted: Dec 7, 2012 4:32 AM
 Plain Text Reply

On Dec 7, 5:25 pm, fom <fomJ...@nyms.net> wrote:
> 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

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

Date Subject Author
12/7/12 fom
12/7/12 Graham Cooper
12/7/12 fom
12/7/12 Graham Cooper
12/7/12 fom

© The Math Forum at NCTM 1994-2017. All Rights Reserved.