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

By removing a line and its associatedline elements from a projective geometry,one obtains an affine geometry.The lines of a 21-point plane each have5 line elements.Every corresponding affine geometry isa 16-point plane for which each linehas 4 line elements.What follows is a faithful algebra ofintensional functions ("intensional" asdescribed by Church when introducingthe lambda-calculus) associated with16 of logical constants that forman affine plane in the namespace andhaving 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 notunderstanding the meaning of "formal")and axioms:LEQ (LEQ,LEQ) = TRULEQ (LEQ,OR) = ANDLEQ (LEQ,DENY) = FLIPLEQ (LEQ,FLIP) = DENYLEQ (LEQ,NIF) = NIMPLEQ (LEQ,NTRU) = XORLEQ (LEQ,AND) = ORLEQ (LEQ,NIMP) = NIFLEQ (LEQ,XOR) = NTRULEQ (LEQ,IMP) = IFLEQ (LEQ,NAND) = NORLEQ (LEQ,TRU) = LEQLEQ (LEQ,IF) = IMPLEQ (LEQ,FIX) = LETLEQ (LEQ,LET) = FIXLEQ (LEQ,NOR) = NANDLEQ (OR,LEQ) = ANDLEQ (OR,OR) = TRULEQ (OR,DENY) = NIMPLEQ (OR,FLIP) = NIFLEQ (OR,NIF) = FLIPLEQ (OR,NTRU) = NORLEQ (OR,AND) = LEQLEQ (OR,NIMP) = DENYLEQ (OR,XOR) = NANDLEQ (OR,IMP) = LETLEQ (OR,NAND) = XORLEQ (OR,TRU) = ORLEQ (OR,IF) = FIXLEQ (OR,FIX) = IFLEQ (OR,LET) = IMPLEQ (OR,NOR) = NTRULEQ (DENY,LEQ) = FLIPLEQ (DENY,OR) = NIMPLEQ (DENY,DENY) = TRULEQ (DENY,FLIP) = LEQLEQ (DENY,NIF) = ANDLEQ (DENY,NTRU) = LETLEQ (DENY,AND) = NIFLEQ (DENY,NIMP) = ORLEQ (DENY,XOR) = FIXLEQ (DENY,IMP) = NORLEQ (DENY,NAND) = IFLEQ (DENY,TRU) = DENYLEQ (DENY,IF) = NANDLEQ (DENY,FIX) = XORLEQ (DENY,LET) = NTRULEQ (DENY,NOR) = IMPLEQ (FLIP,LEQ) = DENYLEQ (FLIP,OR) = NIFLEQ (FLIP,DENY) = LEQLEQ (FLIP,FLIP) = TRULEQ (FLIP,NIF) = ORLEQ (FLIP,NTRU) = FIXLEQ (FLIP,AND) = NIMPLEQ (FLIP,NIMP) = ANDLEQ (FLIP,XOR) = LETLEQ (FLIP,IMP) = NANDLEQ (FLIP,NAND) = IMPLEQ (FLIP,TRU) = FLIPLEQ (FLIP,IF) = NORLEQ (FLIP,FIX) = NTRULEQ (FLIP,LET) = XORLEQ (FLIP,NOR) = IFLEQ (NIF,LEQ) = NIMPLEQ (NIF,OR) = FLIPLEQ (NIF,DENY) = ANDLEQ (NIF,FLIP) = ORLEQ (NIF,NIF) = TRULEQ (NIF,NTRU) = IFLEQ (NIF,AND) = DENYLEQ (NIF,NIMP) = LEQLEQ (NIF,XOR) = IMPLEQ (NIF,IMP) = XORLEQ (NIF,NAND) = LETLEQ (NIF,TRU) = NIFLEQ (NIF,IF) = NTRULEQ (NIF,FIX) = NORLEQ (NIF,LET) = NANDLEQ (NIF,NOR) = FIXLEQ (NTRU,LEQ) = XORLEQ (NTRU,OR) = NORLEQ (NTRU,DENY) = LETLEQ (NTRU,FLIP) = FIXLEQ (NTRU,NIF) = IFLEQ (NTRU,NTRU) = TRULEQ (NTRU,AND) = NANDLEQ (NTRU,NIMP) = IMPLEQ (NTRU,XOR) = LEQLEQ (NTRU,IMP) = NIMPLEQ (NTRU,NAND) = ANDLEQ (NTRU,TRU) = NTRULEQ (NTRU,IF) = NIFLEQ (NTRU,FIX) = FLIPLEQ (NTRU,LET) = DENYLEQ (NTRU,NOR) = ORLEQ (AND,LEQ) = ORLEQ (AND,OR) = LEQLEQ (AND,DENY) = NIFLEQ (AND,FLIP) = NIMPLEQ (AND,NIF) = DENYLEQ (AND,NTRU) = NANDLEQ (AND,AND) = TRULEQ (AND,NIMP) = FLIPLEQ (AND,XOR) = NORLEQ (AND,IMP) = FIXLEQ (AND,NAND) = NTRULEQ (AND,TRU) = ANDLEQ (AND,IF) = LETLEQ (AND,FIX) = IMPLEQ (AND,LET) = IFLEQ (AND,NOR) = XORLEQ (NIMP,LEQ) = NIFLEQ (NIMP,OR) = DENYLEQ (NIMP,DENY) = ORLEQ (NIMP,FLIP) = ANDLEQ (NIMP,NIF) = LEQLEQ (NIMP,NTRU) = IMPLEQ (NIMP,AND) = FLIPLEQ (NIMP,NIMP) = TRULEQ (NIMP,XOR) = IFLEQ (NIMP,IMP) = NTRULEQ (NIMP,NAND) = FIXLEQ (NIMP,TRU) = NIMPLEQ (NIMP,IF) = XORLEQ (NIMP,FIX) = NANDLEQ (NIMP,LET) = NORLEQ (NIMP,NOR) = LETLEQ (XOR,LEQ) = NTRULEQ (XOR,OR) = NANDLEQ (XOR,DENY) = FIXLEQ (XOR,FLIP) = LETLEQ (XOR,NIF) = IMPLEQ (XOR,NTRU) = LEQLEQ (XOR,AND) = NORLEQ (XOR,NIMP) = IFLEQ (XOR,XOR) = TRULEQ (XOR,IMP) = NIFLEQ (XOR,NAND) = ORLEQ (XOR,TRU) = XORLEQ (XOR,IF) = NIMPLEQ (XOR,FIX) = DENYLEQ (XOR,LET) = FLIPLEQ (XOR,NOR) = ANDLEQ (IMP,LEQ) = IFLEQ (IMP,OR) = LETLEQ (IMP,DENY) = NORLEQ (IMP,FLIP) = NANDLEQ (IMP,NIF) = XORLEQ (IMP,NTRU) = NIMPLEQ (IMP,AND) = FIXLEQ (IMP,NIMP) = NTRULEQ (IMP,XOR) = NIFLEQ (IMP,IMP) = TRULEQ (IMP,NAND) = FLIPLEQ (IMP,TRU) = IMPLEQ (IMP,IF) = LEQLEQ (IMP,FIX) = ANDLEQ (IMP,LET) = ORLEQ (IMP,NOR) = DENYLEQ (NAND,LEQ) = NORLEQ (NAND,OR) = XORLEQ (NAND,DENY) = IFLEQ (NAND,FLIP) = IMPLEQ (NAND,NIF) = LETLEQ (NAND,NTRU) = ANDLEQ (NAND,AND) = NTRULEQ (NAND,NIMP) = FIXLEQ (NAND,XOR) = ORLEQ (NAND,IMP) = FLIPLEQ (NAND,NAND) = TRULEQ (NAND,TRU) = NANDLEQ (NAND,IF) = DENYLEQ (NAND,FIX) = NIMPLEQ (NAND,LET) = NIFLEQ (NAND,NOR) = LEQLEQ (TRU,LEQ) = LEQLEQ (TRU,OR) = ORLEQ (TRU,DENY) = DENYLEQ (TRU,FLIP) = FLIPLEQ (TRU,NIF) = NIFLEQ (TRU,NTRU) = NTRULEQ (TRU,AND) = ANDLEQ (TRU,NIMP) = NIMPLEQ (TRU,XOR) = XORLEQ (TRU,IMP) = IMPLEQ (TRU,NAND) = NANDLEQ (TRU,TRU) = TRULEQ (TRU,IF) = IFLEQ (TRU,FIX) = FIXLEQ (TRU,LET) = LETLEQ (TRU,NOR) = NORLEQ (IF,LEQ) = IMPLEQ (IF,OR) = FIXLEQ (IF,DENY) = NANDLEQ (IF,FLIP) = NORLEQ (IF,NIF) = NTRULEQ (IF,NTRU) = NIFLEQ (IF,AND) = LETLEQ (IF,NIMP) = XORLEQ (IF,XOR) = NIMPLEQ (IF,IMP) = LEQLEQ (IF,NAND) = DENYLEQ (IF,TRU) = IFLEQ (IF,IF) = TRULEQ (IF,FIX) = ORLEQ (IF,LET) = ANDLEQ (IF,NOR) = FLIPLEQ (FIX,LEQ) = LETLEQ (FIX,OR) = IFLEQ (FIX,DENY) = XORLEQ (FIX,FLIP) = NTRULEQ (FIX,NIF) = NORLEQ (FIX,NTRU) = FLIPLEQ (FIX,AND) = IMPLEQ (FIX,NIMP) = NANDLEQ (FIX,XOR) = DENYLEQ (FIX,IMP) = ANDLEQ (FIX,NAND) = NIMPLEQ (FIX,TRU) = FIXLEQ (FIX,IF) = ORLEQ (FIX,FIX) = TRULEQ (FIX,LET) = LEQLEQ (FIX,NOR) = NIFLEQ (LET,LEQ) = FIXLEQ (LET,OR) = IMPLEQ (LET,DENY) = NTRULEQ (LET,FLIP) = XORLEQ (LET,NIF) = NANDLEQ (LET,NTRU) = DENYLEQ (LET,AND) = IFLEQ (LET,NIMP) = NORLEQ (LET,XOR) = FLIPLEQ (LET,IMP) = ORLEQ (LET,NAND) = NIFLEQ (LET,TRU) = LETLEQ (LET,IF) = ANDLEQ (LET,FIX) = LEQLEQ (LET,LET) = TRULEQ (LET,NOR) = NIMPLEQ (NOR,LEQ) = NANDLEQ (NOR,OR) = NTRULEQ (NOR,DENY) = IMPLEQ (NOR,FLIP) = IFLEQ (NOR,NIF) = FIXLEQ (NOR,NTRU) = ORLEQ (NOR,AND) = XORLEQ (NOR,NIMP) = LETLEQ (NOR,XOR) = ANDLEQ (NOR,IMP) = DENYLEQ (NOR,NAND) = LEQLEQ (NOR,TRU) = NORLEQ (NOR,IF) = FLIPLEQ (NOR,FIX) = NIFLEQ (NOR,LET) = NIMPLEQ (NOR,NOR) = TRUOR (LEQ,LEQ) = LEQOR (LEQ,OR) = TRUOR (LEQ,DENY) = IFOR (LEQ,FLIP) = IMPOR (LEQ,NIF) = IMPOR (LEQ,NTRU) = LEQOR (LEQ,AND) = LEQOR (LEQ,NIMP) = IFOR (LEQ,XOR) = TRUOR (LEQ,IMP) = IMPOR (LEQ,NAND) = TRUOR (LEQ,TRU) = TRUOR (LEQ,IF) = IFOR (LEQ,FIX) = IFOR (LEQ,LET) = IMPOR (LEQ,NOR) = LEQOR (OR,LEQ) = TRUOR (OR,OR) = OROR (OR,DENY) = TRUOR (OR,FLIP) = TRUOR (OR,NIF) = OROR (OR,NTRU) = OROR (OR,AND) = OROR (OR,NIMP) = OROR (OR,XOR) = OROR (OR,IMP) = TRUOR (OR,NAND) = TRUOR (OR,TRU) = TRUOR (OR,IF) = TRUOR (OR,FIX) = OROR (OR,LET) = OROR (OR,NOR) = TRUOR (DENY,LEQ) = IFOR (DENY,OR) = TRUOR (DENY,DENY) = DENYOR (DENY,FLIP) = NANDOR (DENY,NIF) = NANDOR (DENY,NTRU) = DENYOR (DENY,AND) = IFOR (DENY,NIMP) = DENYOR (DENY,XOR) = NANDOR (DENY,IMP) = TRUOR (DENY,NAND) = NANDOR (DENY,TRU) = TRUOR (DENY,IF) = IFOR (DENY,FIX) = IFOR (DENY,LET) = TRUOR (DENY,NOR) = DENYOR (FLIP,LEQ) = IMPOR (FLIP,OR) = TRUOR (FLIP,DENY) = NANDOR (FLIP,FLIP) = FLIPOR (FLIP,NIF) = FLIPOR (FLIP,NTRU) = FLIPOR (FLIP,AND) = IMPOR (FLIP,NIMP) = NANDOR (FLIP,XOR) = NANDOR (FLIP,IMP) = IMPOR (FLIP,NAND) = NANDOR (FLIP,TRU) = TRUOR (FLIP,IF) = TRUOR (FLIP,FIX) = TRUOR (FLIP,LET) = IMPOR (FLIP,NOR) = FLIPOR (NIF,LEQ) = IMPOR (NIF,OR) = OROR (NIF,DENY) = NANDOR (NIF,FLIP) = FLIPOR (NIF,NIF) = NIFOR (NIF,NTRU) = NIFOR (NIF,AND) = LETOR (NIF,NIMP) = XOROR (NIF,XOR) = XOROR (NIF,IMP) = IMPOR (NIF,NAND) = NANDOR (NIF,TRU) = TRUOR (NIF,IF) = TRUOR (NIF,FIX) = OROR (NIF,LET) = LETOR (NIF,NOR) = FLIPOR (NTRU,LEQ) = LEQOR (NTRU,OR) = OROR (NTRU,DENY) = DENYOR (NTRU,FLIP) = FLIPOR (NTRU,NIF) = NIFOR (NTRU,NTRU) = NTRUOR (NTRU,AND) = ANDOR (NTRU,NIMP) = NIMPOR (NTRU,XOR) = XOROR (NTRU,IMP) = IMPOR (NTRU,NAND) = NANDOR (NTRU,TRU) = TRUOR (NTRU,IF) = IFOR (NTRU,FIX) = FIXOR (NTRU,LET) = LETOR (NTRU,NOR) = NOROR (AND,LEQ) = LEQOR (AND,OR) = OROR (AND,DENY) = IFOR (AND,FLIP) = IMPOR (AND,NIF) = LETOR (AND,NTRU) = ANDOR (AND,AND) = ANDOR (AND,NIMP) = FIXOR (AND,XOR) = OROR (AND,IMP) = IMPOR (AND,NAND) = TRUOR (AND,TRU) = TRUOR (AND,IF) = IFOR (AND,FIX) = FIXOR (AND,LET) = LETOR (AND,NOR) = LEQOR (NIMP,LEQ) = IFOR (NIMP,OR) = OROR (NIMP,DENY) = DENYOR (NIMP,FLIP) = NANDOR (NIMP,NIF) = XOROR (NIMP,NTRU) = NIMPOR (NIMP,AND) = FIXOR (NIMP,NIMP) = NIMPOR (NIMP,XOR) = XOROR (NIMP,IMP) = TRUOR (NIMP,NAND) = NANDOR (NIMP,TRU) = TRUOR (NIMP,IF) = IFOR (NIMP,FIX) = FIXOR (NIMP,LET) = OROR (NIMP,NOR) = DENYOR (XOR,LEQ) = TRUOR (XOR,OR) = OROR (XOR,DENY) = NANDOR (XOR,FLIP) = NANDOR (XOR,NIF) = XOROR (XOR,NTRU) = XOROR (XOR,AND) = OROR (XOR,NIMP) = XOROR (XOR,XOR) = XOROR (XOR,IMP) = TRUOR (XOR,NAND) = NANDOR (XOR,TRU) = TRUOR (XOR,IF) = TRUOR (XOR,FIX) = OROR (XOR,LET) = OROR (XOR,NOR) = NANDOR (IMP,LEQ) = IMPOR (IMP,OR) = TRUOR (IMP,DENY) = TRUOR (IMP,FLIP) = IMPOR (IMP,NIF) = IMPOR (IMP,NTRU) = IMPOR (IMP,AND) = IMPOR (IMP,NIMP) = TRUOR (IMP,XOR) = TRUOR (IMP,IMP) = IMPOR (IMP,NAND) = TRUOR (IMP,TRU) = TRUOR (IMP,IF) = TRUOR (IMP,FIX) = TRUOR (IMP,LET) = IMPOR (IMP,NOR) = IMPOR (NAND,LEQ) = TRUOR (NAND,OR) = TRUOR (NAND,DENY) = NANDOR (NAND,FLIP) = NANDOR (NAND,NIF) = NANDOR (NAND,NTRU) = NANDOR (NAND,AND) = TRUOR (NAND,NIMP) = NANDOR (NAND,XOR) = NANDOR (NAND,IMP) = TRUOR (NAND,NAND) = NANDOR (NAND,TRU) = TRUOR (NAND,IF) = TRUOR (NAND,FIX) = TRUOR (NAND,LET) = TRUOR (NAND,NOR) = NANDOR (TRU,LEQ) = TRUOR (TRU,OR) = TRUOR (TRU,DENY) = TRUOR (TRU,FLIP) = TRUOR (TRU,NIF) = TRUOR (TRU,NTRU) = TRUOR (TRU,AND) = TRUOR (TRU,NIMP) = TRUOR (TRU,XOR) = TRUOR (TRU,IMP) = TRUOR (TRU,NAND) = TRUOR (TRU,TRU) = TRUOR (TRU,IF) = TRUOR (TRU,FIX) = TRUOR (TRU,LET) = TRUOR (TRU,NOR) = TRUOR (IF,LEQ) = IFOR (IF,OR) = TRUOR (IF,DENY) = IFOR (IF,FLIP) = TRUOR (IF,NIF) = TRUOR (IF,NTRU) = IFOR (IF,AND) = IFOR (IF,NIMP) = IFOR (IF,XOR) = TRUOR (IF,IMP) = TRUOR (IF,NAND) = TRUOR (IF,TRU) = TRUOR (IF,IF) = IFOR (IF,FIX) = IFOR (IF,LET) = TRUOR (IF,NOR) = IFOR (FIX,LEQ) = IFOR (FIX,OR) = OROR (FIX,DENY) = IFOR (FIX,FLIP) = TRUOR (FIX,NIF) = OROR (FIX,NTRU) = FIXOR (FIX,AND) = FIXOR (FIX,NIMP) = FIXOR (FIX,XOR) = OROR (FIX,IMP) = TRUOR (FIX,NAND) = TRUOR (FIX,TRU) = TRUOR (FIX,IF) = IFOR (FIX,FIX) = FIXOR (FIX,LET) = OROR (FIX,NOR) = IFOR (LET,LEQ) = IMPOR (LET,OR) = OROR (LET,DENY) = TRUOR (LET,FLIP) = IMPOR (LET,NIF) = LETOR (LET,NTRU) = LETOR (LET,AND) = LETOR (LET,NIMP) = OROR (LET,XOR) = OROR (LET,IMP) = IMPOR (LET,NAND) = TRUOR (LET,TRU) = TRUOR (LET,IF) = TRUOR (LET,FIX) = OROR (LET,LET) = LETOR (LET,NOR) = IMPOR (NOR,LEQ) = LEQOR (NOR,OR) = TRUOR (NOR,DENY) = DENYOR (NOR,FLIP) = FLIPOR (NOR,NIF) = FLIPOR (NOR,NTRU) = NOROR (NOR,AND) = LEQOR (NOR,NIMP) = DENYOR (NOR,XOR) = NANDOR (NOR,IMP) = IMPOR (NOR,NAND) = NANDOR (NOR,TRU) = TRUOR (NOR,IF) = IFOR (NOR,FIX) = IFOR (NOR,LET) = IMPOR (NOR,NOR) = NORDENY (LEQ,LEQ) = XORDENY (LEQ,OR) = NORDENY (LEQ,DENY) = LETDENY (LEQ,FLIP) = FIXDENY (LEQ,NIF) = IFDENY (LEQ,NTRU) = TRUDENY (LEQ,AND) = NANDDENY (LEQ,NIMP) = IMPDENY (LEQ,XOR) = LEQDENY (LEQ,IMP) = NIMPDENY (LEQ,NAND) = ANDDENY (LEQ,TRU) = NTRUDENY (LEQ,IF) = NIFDENY (LEQ,FIX) = FLIPDENY (LEQ,LET) = DENYDENY (LEQ,NOR) = ORDENY (OR,LEQ) = XORDENY (OR,OR) = NORDENY (OR,DENY) = LETDENY (OR,FLIP) = FIXDENY (OR,NIF) = IFDENY (OR,NTRU) = TRUDENY (OR,AND) = NANDDENY (OR,NIMP) = IMPDENY (OR,XOR) = LEQDENY (OR,IMP) = NIMPDENY (OR,NAND) = ANDDENY (OR,TRU) = NTRUDENY (OR,IF) = NIFDENY (OR,FIX) = FLIPDENY (OR,LET) = DENYDENY (OR,NOR) = ORDENY (DENY,LEQ) = XORDENY (DENY,OR) = NORDENY (DENY,DENY) = LETDENY (DENY,FLIP) = FIXDENY (DENY,NIF) = IFDENY (DENY,NTRU) = TRUDENY (DENY,AND) = NANDDENY (DENY,NIMP) = IMPDENY (DENY,XOR) = LEQDENY (DENY,IMP) = NIMPDENY (DENY,NAND) = ANDDENY (DENY,TRU) = NTRUDENY (DENY,IF) = NIFDENY (DENY,FIX) = FLIPDENY (DENY,LET) = DENYDENY (DENY,NOR) = ORDENY (FLIP,LEQ) = XORDENY (FLIP,OR) = NORDENY (FLIP,DENY) = LETDENY (FLIP,FLIP) = FIXDENY (FLIP,NIF) = IFDENY (FLIP,NTRU) = TRUDENY (FLIP,AND) = NANDDENY (FLIP,NIMP) = IMPDENY (FLIP,XOR) = LEQDENY (FLIP,IMP) = NIMPDENY (FLIP,NAND) = ANDDENY (FLIP,TRU) = NTRUDENY (FLIP,IF) = NIFDENY (FLIP,FIX) = FLIPDENY (FLIP,LET) = DENYDENY (FLIP,NOR) = ORDENY (NIF,LEQ) = XORDENY (NIF,OR) = NORDENY (NIF,DENY) = LETDENY (NIF,FLIP) = FIXDENY (NIF,NIF) = IFDENY (NIF,NTRU) = TRUDENY (NIF,AND) = NANDDENY (NIF,NIMP) = IMPDENY (NIF,XOR) = LEQDENY (NIF,IMP) = NIMPDENY (NIF,NAND) = ANDDENY (NIF,TRU) = NTRUDENY (NIF,IF) = NIFDENY (NIF,FIX) = FLIPDENY (NIF,LET) = DENYDENY (NIF,NOR) = ORDENY (NTRU,LEQ) = XORDENY (NTRU,OR) = NORDENY (NTRU,DENY) = LETDENY (NTRU,FLIP) = FIXDENY (NTRU,NIF) = IFDENY (NTRU,NTRU) = TRUDENY (NTRU,AND) = NANDDENY (NTRU,NIMP) = IMPDENY (NTRU,XOR) = LEQDENY (NTRU,IMP) = NIMPDENY (NTRU,NAND) = ANDDENY (NTRU,TRU) = NTRUDENY (NTRU,IF) = NIFDENY (NTRU,FIX) = FLIPDENY (NTRU,LET) = DENYDENY (NTRU,NOR) = ORDENY (AND,LEQ) = XORDENY (AND,OR) = NORDENY (AND,DENY) = LETDENY (AND,FLIP) = FIXDENY (AND,NIF) = IFDENY (AND,NTRU) = TRUDENY (AND,AND) = NANDDENY (AND,NIMP) = IMPDENY (AND,XOR) = LEQDENY (AND,IMP) = NIMPDENY (AND,NAND) = ANDDENY (AND,TRU) = NTRUDENY (AND,IF) = NIFDENY (AND,FIX) = FLIPDENY (AND,LET) = DENYDENY (AND,NOR) = ORDENY (NIMP,LEQ) = XORDENY (NIMP,OR) = NORDENY (NIMP,DENY) = LETDENY (NIMP,FLIP) = FIXDENY (NIMP,NIF) = IFDENY (NIMP,NTRU) = TRUDENY (NIMP,AND) = NANDDENY (NIMP,NIMP) = IMPDENY (NIMP,XOR) = LEQDENY (NIMP,IMP) = NIMPDENY (NIMP,NAND) = ANDDENY (NIMP,TRU) = NTRUDENY (NIMP,IF) = NIFDENY (NIMP,FIX) = FLIPDENY (NIMP,LET) = DENYDENY (NIMP,NOR) = ORDENY (XOR,LEQ) = XORDENY (XOR,OR) = NORDENY (XOR,DENY) = LETDENY (XOR,FLIP) = FIXDENY (XOR,NIF) = IFDENY (XOR,NTRU) = TRUDENY (XOR,AND) = NANDDENY (XOR,NIMP) = IMPDENY (XOR,XOR) = LEQDENY (XOR,IMP) = NIMPDENY (XOR,NAND) = ANDDENY (XOR,TRU) = NTRUDENY (XOR,IF) = NIFDENY (XOR,FIX) = FLIPDENY (XOR,LET) = DENYDENY (XOR,NOR) = ORDENY (IMP,LEQ) = XORDENY (IMP,OR) = NORDENY (IMP,DENY) = LETDENY (IMP,FLIP) = FIXDENY (IMP,NIF) = IFDENY (IMP,NTRU) = TRUDENY (IMP,AND) = NANDDENY (IMP,NIMP) = IMPDENY (IMP,XOR) = LEQDENY (IMP,IMP) = NIMPDENY (IMP,NAND) = ANDDENY (IMP,TRU) = NTRUDENY (IMP,IF) = NIFDENY (IMP,FIX) = FLIPDENY (IMP,LET) = DENYDENY (IMP,NOR) = ORDENY (NAND,LEQ) = XORDENY (NAND,OR) = NORDENY (NAND,DENY) = LETDENY (NAND,FLIP) = FIXDENY (NAND,NIF) = IFDENY (NAND,NTRU) = TRUDENY (NAND,AND) = NANDDENY (NAND,NIMP) = IMPDENY (NAND,XOR) = LEQDENY (NAND,IMP) = NIMPDENY (NAND,NAND) = ANDDENY (NAND,TRU) = NTRUDENY (NAND,IF) = NIFDENY (NAND,FIX) = FLIPDENY (NAND,LET) = DENYDENY (NAND,NOR) = ORDENY (TRU,LEQ) = XORDENY (TRU,OR) = NORDENY (TRU,DENY) = LETDENY (TRU,FLIP) = FIXDENY (TRU,NIF) = IFDENY (TRU,NTRU) = TRUDENY (TRU,AND) = NANDDENY (TRU,NIMP) = IMPDENY (TRU,XOR) = LEQDENY (TRU,IMP) = NIMPDENY (TRU,NAND) = ANDDENY (TRU,TRU) = NTRUDENY (TRU,IF) = NIFDENY (TRU,FIX) = FLIPDENY (TRU,LET) = DENYDENY (TRU,NOR) = ORDENY (IF,LEQ) = XORDENY (IF,OR) = NORDENY (IF,DENY) = LETDENY (IF,FLIP) = FIXDENY (IF,NIF) = IFDENY (IF,NTRU) = TRUDENY (IF,AND) = NANDDENY (IF,NIMP) = IMPDENY (IF,XOR) = LEQDENY (IF,IMP) = NIMPDENY (IF,NAND) = ANDDENY (IF,TRU) = NTRUDENY (IF,IF) = NIFDENY (IF,FIX) = FLIPDENY (IF,LET) = DENYDENY (IF,NOR) = ORDENY (FIX,LEQ) = XORDENY (FIX,OR) = NORDENY (FIX,DENY) = LETDENY (FIX,FLIP) = FIXDENY (FIX,NIF) = IFDENY (FIX,NTRU) = TRUDENY (FIX,AND) = NANDDENY (FIX,NIMP) = IMPDENY (FIX,XOR) = LEQDENY (FIX,IMP) = NIMPDENY (FIX,NAND) = ANDDENY (FIX,TRU) = NTRUDENY (FIX,IF) = NIFDENY (FIX,FIX) = FLIPDENY (FIX,LET) = DENYDENY (FIX,NOR) = ORDENY (LET,LEQ) = XORDENY (LET,OR) = NORDENY (LET,DENY) = LETDENY (LET,FLIP) = FIXDENY (LET,NIF) = IFDENY (LET,NTRU) = TRUDENY (LET,AND) = NANDDENY (LET,NIMP) = IMPDENY (LET,XOR) = LEQDENY (LET,IMP) = NIMPDENY (LET,NAND) = ANDDENY (LET,TRU) = NTRUDENY (LET,IF) = NIFDENY (LET,FIX) = FLIPDENY (LET,LET) = DENYDENY (LET,NOR) = ORDENY (NOR,LEQ) = XORDENY (NOR,OR) = NORDENY (NOR,DENY) = LETDENY (NOR,FLIP) = FIXDENY (NOR,NIF) = IFDENY (NOR,NTRU) = TRUDENY (NOR,AND) = NANDDENY (NOR,NIMP) = IMPDENY (NOR,XOR) = LEQDENY (NOR,IMP) = NIMPDENY (NOR,NAND) = ANDDENY (NOR,TRU) = NTRUDENY (NOR,IF) = NIFDENY (NOR,FIX) = FLIPDENY (NOR,LET) = DENYDENY (NOR,NOR) = ORFLIP (LEQ,LEQ) = XORFLIP (LEQ,OR) = XORFLIP (LEQ,DENY) = XORFLIP (LEQ,FLIP) = XORFLIP (LEQ,NIF) = XORFLIP (LEQ,NTRU) = XORFLIP (LEQ,AND) = XORFLIP (LEQ,NIMP) = XORFLIP (LEQ,XOR) = XORFLIP (LEQ,IMP) = XORFLIP (LEQ,NAND) = XORFLIP (LEQ,TRU) = XORFLIP (LEQ,IF) = XORFLIP (LEQ,FIX) = XORFLIP (LEQ,LET) = XORFLIP (LEQ,NOR) = XORFLIP (OR,LEQ) = NORFLIP (OR,OR) = NORFLIP (OR,DENY) = NORFLIP (OR,FLIP) = NORFLIP (OR,NIF) = NORFLIP (OR,NTRU) = NORFLIP (OR,AND) = NORFLIP (OR,NIMP) = NORFLIP (OR,XOR) = NORFLIP (OR,IMP) = NORFLIP (OR,NAND) = NORFLIP (OR,TRU) = NORFLIP (OR,IF) = NORFLIP (OR,FIX) = NORFLIP (OR,LET) = NORFLIP (OR,NOR) = NORFLIP (DENY,LEQ) = LETFLIP (DENY,OR) = LETFLIP (DENY,DENY) = LETFLIP (DENY,FLIP) = LETFLIP (DENY,NIF) = LETFLIP (DENY,NTRU) = LETFLIP (DENY,AND) = LETFLIP (DENY,NIMP) = LETFLIP (DENY,XOR) = LETFLIP (DENY,IMP) = LETFLIP (DENY,NAND) = LETFLIP (DENY,TRU) = LETFLIP (DENY,IF) = LETFLIP (DENY,FIX) = LETFLIP (DENY,LET) = LETFLIP (DENY,NOR) = LETFLIP (FLIP,LEQ) = FIXFLIP (FLIP,OR) = FIXFLIP (FLIP,DENY) = FIXFLIP (FLIP,FLIP) = FIXFLIP (FLIP,NIF) = FIXFLIP (FLIP,NTRU) = FIXFLIP (FLIP,AND) = FIXFLIP (FLIP,NIMP) = FIXFLIP (FLIP,XOR) = FIXFLIP (FLIP,IMP) = FIXFLIP (FLIP,NAND) = FIXFLIP (FLIP,TRU) = FIXFLIP (FLIP,IF) = FIXFLIP (FLIP,FIX) = FIXFLIP (FLIP,LET) = FIXFLIP (FLIP,NOR) = FIXFLIP (NIF,LEQ) = IFFLIP (NIF,OR) = IFFLIP (NIF,DENY) = IFFLIP (NIF,FLIP) = IFFLIP (NIF,NIF) = IFFLIP (NIF,NTRU) = IFFLIP (NIF,AND) = IFFLIP (NIF,NIMP) = IFFLIP (NIF,XOR) = IFFLIP (NIF,IMP) = IFFLIP (NIF,NAND) = IFFLIP (NIF,TRU) = IFFLIP (NIF,IF) = IFFLIP (NIF,FIX) = IFFLIP (NIF,LET) = IFFLIP (NIF,NOR) = IFFLIP (NTRU,LEQ) = TRUFLIP (NTRU,OR) = TRUFLIP (NTRU,DENY) = TRUFLIP (NTRU,FLIP) = TRUFLIP (NTRU,NIF) = TRUFLIP (NTRU,NTRU) = TRUFLIP (NTRU,AND) = TRUFLIP (NTRU,NIMP) = TRUFLIP (NTRU,XOR) = TRUFLIP (NTRU,IMP) = TRUFLIP (NTRU,NAND) = TRUFLIP (NTRU,TRU) = TRUFLIP (NTRU,IF) = TRUFLIP (NTRU,FIX) = TRUFLIP (NTRU,LET) = TRUFLIP (NTRU,NOR) = TRUFLIP (AND,LEQ) = NANDFLIP (AND,OR) = NANDFLIP (AND,DENY) = NANDFLIP (AND,FLIP) = NANDFLIP (AND,NIF) = NANDFLIP (AND,NTRU) = NANDFLIP (AND,AND) = NANDFLIP (AND,NIMP) = NANDFLIP (AND,XOR) = NANDFLIP (AND,IMP) = NANDFLIP (AND,NAND) = NANDFLIP (AND,TRU) = NANDFLIP (AND,IF) = NANDFLIP (AND,FIX) = NANDFLIP (AND,LET) = NANDFLIP (AND,NOR) = NANDFLIP (NIMP,LEQ) = IMPFLIP (NIMP,OR) = IMPFLIP (NIMP,DENY) = IMPFLIP (NIMP,FLIP) = IMPFLIP (NIMP,NIF) = IMPFLIP (NIMP,NTRU) = IMPFLIP (NIMP,AND) = IMPFLIP (NIMP,NIMP) = IMPFLIP (NIMP,XOR) = IMPFLIP (NIMP,IMP) = IMPFLIP (NIMP,NAND) = IMPFLIP (NIMP,TRU) = IMPFLIP (NIMP,IF) = IMPFLIP (NIMP,FIX) = IMPFLIP (NIMP,LET) = IMPFLIP (NIMP,NOR) = IMPFLIP (XOR,LEQ) = LEQFLIP (XOR,OR) = LEQFLIP (XOR,DENY) = LEQFLIP (XOR,FLIP) = LEQFLIP (XOR,NIF) = LEQFLIP (XOR,NTRU) = LEQFLIP (XOR,AND) = LEQFLIP (XOR,NIMP) = LEQFLIP (XOR,XOR) = LEQFLIP (XOR,IMP) = LEQFLIP (XOR,NAND) = LEQFLIP (XOR,TRU) = LEQFLIP (XOR,IF) = LEQFLIP (XOR,FIX) = LEQFLIP (XOR,LET) = LEQFLIP (XOR,NOR) = LEQFLIP (IMP,LEQ) = NIMPFLIP (IMP,OR) = NIMPFLIP (IMP,DENY) = NIMPFLIP (IMP,FLIP) = NIMPFLIP (IMP,NIF) = NIMPFLIP (IMP,NTRU) = NIMPFLIP (IMP,AND) = NIMPFLIP (IMP,NIMP) = NIMPFLIP (IMP,XOR) = NIMPFLIP (IMP,IMP) = NIMPFLIP (IMP,NAND) = NIMPFLIP (IMP,TRU) = NIMPFLIP (IMP,IF) = NIMPFLIP (IMP,FIX) = NIMPFLIP (IMP,LET) = NIMPFLIP (IMP,NOR) = NIMPFLIP (NAND,LEQ) = ANDFLIP (NAND,OR) = ANDFLIP (NAND,DENY) = ANDFLIP (NAND,FLIP) = ANDFLIP (NAND,NIF) = ANDFLIP (NAND,NTRU) = ANDFLIP (NAND,AND) = ANDFLIP (NAND,NIMP) = ANDFLIP (NAND,XOR) = ANDFLIP (NAND,IMP) = ANDFLIP (NAND,NAND) = ANDFLIP (NAND,TRU) = ANDFLIP (NAND,IF) = ANDFLIP (NAND,FIX) = ANDFLIP (NAND,LET) = ANDFLIP (NAND,NOR) = ANDFLIP (TRU,LEQ) = NTRUFLIP (TRU,OR) = NTRUFLIP (TRU,DENY) = NTRUFLIP (TRU,FLIP) = NTRUFLIP (TRU,NIF) = NTRUFLIP (TRU,NTRU) = NTRUFLIP (TRU,AND) = NTRUFLIP (TRU,NIMP) = NTRUFLIP (TRU,XOR) = NTRUFLIP (TRU,IMP) = NTRUFLIP (TRU,NAND) = NTRUFLIP (TRU,TRU) = NTRUFLIP (TRU,IF) = NTRUFLIP (TRU,FIX) = NTRUFLIP (TRU,LET) = NTRUFLIP (TRU,NOR) = NTRUFLIP (IF,LEQ) = NIFFLIP (IF,OR) = NIFFLIP (IF,DENY) = NIFFLIP (IF,FLIP) = NIFFLIP (IF,NIF) = NIFFLIP (IF,NTRU) = NIFFLIP (IF,AND) = NIFFLIP (IF,NIMP) = NIFFLIP (IF,XOR) = NIFFLIP (IF,IMP) = NIFFLIP (IF,NAND) = NIFFLIP (IF,TRU) = NIFFLIP (IF,IF) = NIFFLIP (IF,FIX) = NIFFLIP (IF,LET) = NIFFLIP (IF,NOR) = NIFFLIP (FIX,LEQ) = FLIPFLIP (FIX,OR) = FLIPFLIP (FIX,DENY) = FLIPFLIP (FIX,FLIP) = FLIPFLIP (FIX,NIF) = FLIPFLIP (FIX,NTRU) = FLIPFLIP (FIX,AND) = FLIPFLIP (FIX,NIMP) = FLIPFLIP (FIX,XOR) = FLIPFLIP (FIX,IMP) = FLIPFLIP (FIX,NAND) = FLIPFLIP (FIX,TRU) = FLIPFLIP (FIX,IF) = FLIPFLIP (FIX,FIX) = FLIPFLIP (FIX,LET) = FLIPFLIP (FIX,NOR) = FLIPFLIP (LET,LEQ) = DENYFLIP (LET,OR) = DENYFLIP (LET,DENY) = DENYFLIP (LET,FLIP) = DENYFLIP (LET,NIF) = DENYFLIP (LET,NTRU) = DENYFLIP (LET,AND) = DENYFLIP (LET,NIMP) = DENYFLIP (LET,XOR) = DENYFLIP (LET,IMP) = DENYFLIP (LET,NAND) = DENYFLIP (LET,TRU) = DENYFLIP (LET,IF) = DENYFLIP (LET,FIX) = DENYFLIP (LET,LET) = DENYFLIP (LET,NOR) = DENYFLIP (NOR,LEQ) = ORFLIP (NOR,OR) = ORFLIP (NOR,DENY) = ORFLIP (NOR,FLIP) = ORFLIP (NOR,NIF) = ORFLIP (NOR,NTRU) = ORFLIP (NOR,AND) = ORFLIP (NOR,NIMP) = ORFLIP (NOR,XOR) = ORFLIP (NOR,IMP) = ORFLIP (NOR,NAND) = ORFLIP (NOR,TRU) = ORFLIP (NOR,IF) = ORFLIP (NOR,FIX) = ORFLIP (NOR,LET) = ORFLIP (NOR,NOR) = ORNIF (LEQ,LEQ) = NTRUNIF (LEQ,OR) = XORNIF (LEQ,DENY) = NIMPNIF (LEQ,FLIP) = NIFNIF (LEQ,NIF) = NIFNIF (LEQ,NTRU) = NTRUNIF (LEQ,AND) = NTRUNIF (LEQ,NIMP) = NIMPNIF (LEQ,XOR) = XORNIF (LEQ,IMP) = NIFNIF (LEQ,NAND) = XORNIF (LEQ,TRU) = XORNIF (LEQ,IF) = NIMPNIF (LEQ,FIX) = NIMPNIF (LEQ,LET) = NIFNIF (LEQ,NOR) = NTRUNIF (OR,LEQ) = NORNIF (OR,OR) = NTRUNIF (OR,DENY) = NORNIF (OR,FLIP) = NORNIF (OR,NIF) = NTRUNIF (OR,NTRU) = NTRUNIF (OR,AND) = NTRUNIF (OR,NIMP) = NTRUNIF (OR,XOR) = NTRUNIF (OR,IMP) = NORNIF (OR,NAND) = NORNIF (OR,TRU) = NORNIF (OR,IF) = NORNIF (OR,FIX) = NTRUNIF (OR,LET) = NTRUNIF (OR,NOR) = NORNIF (DENY,LEQ) = ANDNIF (DENY,OR) = LETNIF (DENY,DENY) = NTRUNIF (DENY,FLIP) = NIFNIF (DENY,NIF) = NIFNIF (DENY,NTRU) = NTRUNIF (DENY,AND) = ANDNIF (DENY,NIMP) = NTRUNIF (DENY,XOR) = NIFNIF (DENY,IMP) = LETNIF (DENY,NAND) = NIFNIF (DENY,TRU) = LETNIF (DENY,IF) = ANDNIF (DENY,FIX) = ANDNIF (DENY,LET) = LETNIF (DENY,NOR) = NTRUNIF (FLIP,LEQ) = ANDNIF (FLIP,OR) = FIXNIF (FLIP,DENY) = NIMPNIF (FLIP,FLIP) = NTRUNIF (FLIP,NIF) = NTRUNIF (FLIP,NTRU) = NTRUNIF (FLIP,AND) = ANDNIF (FLIP,NIMP) = NIMPNIF (FLIP,XOR) = NIMPNIF (FLIP,IMP) = ANDNIF (FLIP,NAND) = NIMPNIF (FLIP,TRU) = FIXNIF (FLIP,IF) = FIXNIF (FLIP,FIX) = FIXNIF (FLIP,LET) = ANDNIF (FLIP,NOR) = NTRUNIF (NIF,LEQ) = LEQNIF (NIF,OR) = FIXNIF (NIF,DENY) = DENYNIF (NIF,FLIP) = NORNIF (NIF,NIF) = NTRUNIF (NIF,NTRU) = NTRUNIF (NIF,AND) = ANDNIF (NIF,NIMP) = NIMPNIF (NIF,XOR) = NIMPNIF (NIF,IMP) = LEQNIF (NIF,NAND) = DENYNIF (NIF,TRU) = IFNIF (NIF,IF) = IFNIF (NIF,FIX) = FIXNIF (NIF,LET) = ANDNIF (NIF,NOR) = NORNIF (NTRU,LEQ) = LEQNIF (NTRU,OR) = ORNIF (NTRU,DENY) = DENYNIF (NTRU,FLIP) = FLIPNIF (NTRU,NIF) = NIFNIF (NTRU,NTRU) = NTRUNIF (NTRU,AND) = ANDNIF (NTRU,NIMP) = NIMPNIF (NTRU,XOR) = XORNIF (NTRU,IMP) = IMPNIF (NTRU,NAND) = NANDNIF (NTRU,TRU) = TRUNIF (NTRU,IF) = IFNIF (NTRU,FIX) = FIXNIF (NTRU,LET) = LETNIF (NTRU,NOR) = NORNIF (AND,LEQ) = NORNIF (AND,OR) = XORNIF (AND,DENY) = DENYNIF (AND,FLIP) = FLIPNIF (AND,NIF) = NIFNIF (AND,NTRU) = NTRUNIF (AND,AND) = NTRUNIF (AND,NIMP) = NIMPNIF (AND,XOR) = XORNIF (AND,IMP) = FLIPNIF (AND,NAND) = NANDNIF (AND,TRU) = NANDNIF (AND,IF) = DENYNIF (AND,FIX) = NIMPNIF (AND,LET) = NIFNIF (AND,NOR) = NORNIF (NIMP,LEQ) = LEQNIF (NIMP,OR) = LETNIF (NIMP,DENY) = NORNIF (NIMP,FLIP) = FLIPNIF (NIMP,NIF) = NIFNIF (NIMP,NTRU) = NTRUNIF (NIMP,AND) = ANDNIF (NIMP,NIMP) = NTRUNIF (NIMP,XOR) = NIFNIF (NIMP,IMP) = IMPNIF (NIMP,NAND) = FLIPNIF (NIMP,TRU) = IMPNIF (NIMP,IF) = LEQNIF (NIMP,FIX) = ANDNIF (NIMP,LET) = LETNIF (NIMP,NOR) = NORNIF (XOR,LEQ) = LEQNIF (XOR,OR) = ANDNIF (XOR,DENY) = NORNIF (XOR,FLIP) = NORNIF (XOR,NIF) = NTRUNIF (XOR,NTRU) = NTRUNIF (XOR,AND) = ANDNIF (XOR,NIMP) = NTRUNIF (XOR,XOR) = NTRUNIF (XOR,IMP) = LEQNIF (XOR,NAND) = NORNIF (XOR,TRU) = LEQNIF (XOR,IF) = LEQNIF (XOR,FIX) = ANDNIF (XOR,LET) = ANDNIF (XOR,NOR) = NORNIF (IMP,LEQ) = NTRUNIF (IMP,OR) = NIMPNIF (IMP,DENY) = NIMPNIF (IMP,FLIP) = NTRUNIF (IMP,NIF) = NTRUNIF (IMP,NTRU) = NTRUNIF (IMP,AND) = NTRUNIF (IMP,NIMP) = NIMPNIF (IMP,XOR) = NIMPNIF (IMP,IMP) = NTRUNIF (IMP,NAND) = NIMPNIF (IMP,TRU) = NIMPNIF (IMP,IF) = NIMPNIF (IMP,FIX) = NIMPNIF (IMP,LET) = NTRUNIF (IMP,NOR) = NTRUNIF (NAND,LEQ) = ANDNIF (NAND,OR) = ANDNIF (NAND,DENY) = NTRUNIF (NAND,FLIP) = NTRUNIF (NAND,NIF) = NTRUNIF (NAND,NTRU) = NTRUNIF (NAND,AND) = ANDNIF (NAND,NIMP) = NTRUNIF (NAND,XOR) = NTRUNIF (NAND,IMP) = ANDNIF (NAND,NAND) = NTRUNIF (NAND,TRU) = ANDNIF (NAND,IF) = ANDNIF (NAND,FIX) = ANDNIF (NAND,LET) = ANDNIF (NAND,NOR) = NTRUNIF (TRU,LEQ) = NTRUNIF (TRU,OR) = NTRUNIF (TRU,DENY) = NTRUNIF (TRU,FLIP) = NTRUNIF (TRU,NIF) = NTRUNIF (TRU,NTRU) = NTRUNIF (TRU,AND) = NTRUNIF (TRU,NIMP) = NTRUNIF (TRU,XOR) = NTRUNIF (TRU,IMP) = NTRUNIF (TRU,NAND) = NTRUNIF (TRU,TRU) = NTRUNIF (TRU,IF) = NTRUNIF (TRU,FIX) = NTRUNIF (TRU,LET) = NTRUNIF (TRU,NOR) = NTRUNIF (IF,LEQ) = NTRUNIF (IF,OR) = NIFNIF (IF,DENY) = NTRUNIF (IF,FLIP) = NIFNIF (IF,NIF) = NIFNIF (IF,NTRU) = NTRUNIF (IF,AND) = NTRUNIF (IF,NIMP) = NTRUNIF (IF,XOR) = NIFNIF (IF,IMP) = NIFNIF (IF,NAND) = NIFNIF (IF,TRU) = NIFNIF (IF,IF) = NTRUNIF (IF,FIX) = NTRUNIF (IF,LET) = NIFNIF (IF,NOR) = NTRUNIF (FIX,LEQ) = NORNIF (FIX,OR) = NIFNIF (FIX,DENY) = NORNIF (FIX,FLIP) = FLIPNIF (FIX,NIF) = NIFNIF (FIX,NTRU) = NTRUNIF (FIX,AND) = NTRUNIF (FIX,NIMP) = NTRUNIF (FIX,XOR) = NIFNIF (FIX,IMP) = FLIPNIF (FIX,NAND) = FLIPNIF (FIX,TRU) = FLIPNIF (FIX,IF) = NORNIF (FIX,FIX) = NTRUNIF (FIX,LET) = NIFNIF (FIX,NOR) = NORNIF (LET,LEQ) = NORNIF (LET,OR) = NIMPNIF (LET,DENY) = DENYNIF (LET,FLIP) = NORNIF (LET,NIF) = NTRUNIF (LET,NTRU) = NTRUNIF (LET,AND) = NTRUNIF (LET,NIMP) = NIMPNIF (LET,XOR) = NIMPNIF (LET,IMP) = NORNIF (LET,NAND) = DENYNIF (LET,TRU) = DENYNIF (LET,IF) = DENYNIF (LET,FIX) = NIMPNIF (LET,LET) = NTRUNIF (LET,NOR) = NORNIF (NOR,LEQ) = ANDNIF (NOR,OR) = ORNIF (NOR,DENY) = NIMPNIF (NOR,FLIP) = NIFNIF (NOR,NIF) = NIFNIF (NOR,NTRU) = NTRUNIF (NOR,AND) = ANDNIF (NOR,NIMP) = NIMPNIF (NOR,XOR) = XORNIF (NOR,IMP) = LETNIF (NOR,NAND) = XORNIF (NOR,TRU) = ORNIF (NOR,IF) = FIXNIF (NOR,FIX) = FIXNIF (NOR,LET) = LETNIF (NOR,NOR) = NTRUNTRU (LEQ,LEQ) = NTRUNTRU (LEQ,OR) = NTRUNTRU (LEQ,DENY) = NTRUNTRU (LEQ,FLIP) = NTRUNTRU (LEQ,NIF) = NTRUNTRU (LEQ,NTRU) = NTRUNTRU (LEQ,AND) = NTRUNTRU (LEQ,NIMP) = NTRUNTRU (LEQ,XOR) = NTRUNTRU (LEQ,IMP) = NTRUNTRU (LEQ,NAND) = NTRUNTRU (LEQ,TRU) = NTRUNTRU (LEQ,IF) = NTRUNTRU (LEQ,FIX) = NTRUNTRU (LEQ,LET) = NTRUNTRU (LEQ,NOR) = NTRUNTRU (OR,LEQ) = NTRUNTRU (OR,OR) = NTRUNTRU (OR,DENY) = NTRUNTRU (OR,FLIP) = NTRUNTRU (OR,NIF) = NTRUNTRU (OR,NTRU) = NTRUNTRU (OR,AND) = NTRUNTRU (OR,NIMP) = NTRUNTRU (OR,XOR) = NTRUNTRU (OR,IMP) = NTRUNTRU (OR,NAND) = NTRUNTRU (OR,TRU) = NTRUNTRU (OR,IF) = NTRUNTRU (OR,FIX) = NTRUNTRU (OR,LET) = NTRUNTRU (OR,NOR) = NTRUNTRU (DENY,LEQ) = NTRUNTRU (DENY,OR) = NTRUNTRU (DENY,DENY) = NTRUNTRU (DENY,FLIP) = NTRUNTRU (DENY,NIF) = NTRUNTRU (DENY,NTRU) = NTRUNTRU (DENY,AND) = NTRUNTRU (DENY,NIMP) = NTRUNTRU (DENY,XOR) = NTRUNTRU (DENY,IMP) = NTRUNTRU (DENY,NAND) = NTRUNTRU (DENY,TRU) = NTRUNTRU (DENY,IF) = NTRUNTRU (DENY,FIX) = NTRUNTRU (DENY,LET) = NTRUNTRU (DENY,NOR) = NTRUNTRU (FLIP,LEQ) = NTRUNTRU (FLIP,OR) = NTRUNTRU (FLIP,DENY) = NTRUNTRU (FLIP,FLIP) = NTRUNTRU (FLIP,NIF) = NTRUNTRU (FLIP,NTRU) = NTRUNTRU (FLIP,AND) = NTRUNTRU (FLIP,NIMP) = NTRUNTRU (FLIP,XOR) = NTRUNTRU (FLIP,IMP) = NTRUNTRU (FLIP,NAND) = NTRUNTRU (FLIP,TRU) = NTRUNTRU (FLIP,IF) = NTRUNTRU (FLIP,FIX) = NTRUNTRU (FLIP,LET) = NTRUNTRU (FLIP,NOR) = NTRUNTRU (NIF,LEQ) = NTRUNTRU (NIF,OR) = NTRUNTRU (NIF,DENY) = NTRUNTRU (NIF,FLIP) = NTRUNTRU (NIF,NIF) = NTRUNTRU (NIF,NTRU) = NTRUNTRU (NIF,AND) = NTRUNTRU (NIF,NIMP) = NTRUNTRU (NIF,XOR) = NTRUNTRU (NIF,IMP) = NTRUNTRU (NIF,NAND) = NTRUNTRU (NIF,TRU) = NTRUNTRU (NIF,IF) = NTRUNTRU (NIF,FIX) = NTRUNTRU (NIF,LET) = NTRUNTRU (NIF,NOR) = NTRUNTRU (NTRU,LEQ) = NTRUNTRU (NTRU,OR) = NTRUNTRU (NTRU,DENY) = NTRUNTRU (NTRU,FLIP) = NTRUNTRU (NTRU,NIF) = NTRUNTRU (NTRU,NTRU) = NTRUNTRU (NTRU,AND) = NTRUNTRU (NTRU,NIMP) = NTRUNTRU (NTRU,XOR) = NTRUNTRU (NTRU,IMP) = NTRUNTRU (NTRU,NAND) = NTRUNTRU (NTRU,TRU) = NTRUNTRU (NTRU,IF) = NTRUNTRU (NTRU,FIX) = NTRUNTRU (NTRU,LET) = NTRUNTRU (NTRU,NOR) = NTRUNTRU (AND,LEQ) = NTRUNTRU (AND,OR) = NTRUNTRU (AND,DENY) = NTRUNTRU (AND,FLIP) = NTRUNTRU (AND,NIF) = NTRUNTRU (AND,NTRU) = NTRUNTRU (AND,AND) = NTRUNTRU (AND,NIMP) = NTRUNTRU (AND,XOR) = NTRUNTRU (AND,IMP) = NTRUNTRU (AND,NAND) = NTRUNTRU (AND,TRU) = NTRUNTRU (AND,IF) = NTRUNTRU (AND,FIX) = NTRUNTRU (AND,LET) = NTRUNTRU (AND,NOR) = NTRUNTRU (NIMP,LEQ) = NTRUNTRU (NIMP,OR) = NTRUNTRU (NIMP,DENY) = NTRUNTRU (NIMP,FLIP) = NTRUNTRU (NIMP,NIF) = NTRUNTRU (NIMP,NTRU) = NTRUNTRU (NIMP,AND) = NTRUNTRU (NIMP,NIMP) = NTRUNTRU (NIMP,XOR) = NTRUNTRU (NIMP,IMP) = NTRUNTRU (NIMP,NAND) = NTRUNTRU (NIMP,TRU) = NTRUNTRU (NIMP,IF) = NTRUNTRU (NIMP,FIX) = NTRUNTRU (NIMP,LET) = NTRUNTRU (NIMP,NOR) = NTRUNTRU (XOR,LEQ) = NTRUNTRU (XOR,OR) = NTRUNTRU (XOR,DENY) = NTRUNTRU (XOR,FLIP) = NTRUNTRU (XOR,NIF) = NTRUNTRU (XOR,NTRU) = NTRUNTRU (XOR,AND) = NTRUNTRU (XOR,NIMP) = NTRUNTRU (XOR,XOR) = NTRUNTRU (XOR,IMP) = NTRUNTRU (XOR,NAND) = NTRUNTRU (XOR,TRU) = NTRUNTRU (XOR,IF) = NTRUNTRU (XOR,FIX) = NTRUNTRU (XOR,LET) = NTRUNTRU (XOR,NOR) = NTRUNTRU (IMP,LEQ) = NTRUNTRU (IMP,OR) = NTRUNTRU (IMP,DENY) = NTRUNTRU (IMP,FLIP) = NTRUNTRU (IMP,NIF) = NTRUNTRU (IMP,NTRU) = NTRUNTRU (IMP,AND) = NTRUNTRU (IMP,NIMP) = NTRUNTRU (IMP,XOR) = NTRUNTRU (IMP,IMP) = NTRUNTRU (IMP,NAND) = NTRUNTRU (IMP,TRU) = NTRUNTRU (IMP,IF) = NTRUNTRU (IMP,FIX) = NTRUNTRU (IMP,LET) = NTRUNTRU (IMP,NOR) = NTRUNTRU (NAND,LEQ) = NTRUNTRU (NAND,OR) = NTRUNTRU (NAND,DENY) = NTRUNTRU (NAND,FLIP) = NTRUNTRU (NAND,NIF) = NTRUNTRU (NAND,NTRU) = NTRUNTRU (NAND,AND) = NTRUNTRU (NAND,NIMP) = NTRUNTRU (NAND,XOR) = NTRUNTRU (NAND,IMP) = NTRUNTRU (NAND,NAND) = NTRUNTRU (NAND,TRU) = NTRUNTRU (NAND,IF) = NTRUNTRU (NAND,FIX) = NTRUNTRU (NAND,LET) = NTRUNTRU (NAND,NOR) = NTRUNTRU (TRU,LEQ) = NTRUNTRU (TRU,OR) = NTRUNTRU (TRU,DENY) = NTRUNTRU (TRU,FLIP) = NTRUNTRU (TRU,NIF) = NTRUNTRU (TRU,NTRU) = NTRUNTRU (TRU,AND) = NTRUNTRU (TRU,NIMP) = NTRUNTRU (TRU,XOR) = NTRUNTRU (TRU,IMP) = NTRUNTRU (TRU,NAND) = NTRUNTRU (TRU,TRU) = NTRUNTRU (TRU,IF) = NTRUNTRU (TRU,FIX) = NTRUNTRU (TRU,LET) = NTRUNTRU (TRU,NOR) = NTRUNTRU (IF,LEQ) = NTRUNTRU (IF,OR) = NTRUNTRU (IF,DENY) = NTRUNTRU (IF,FLIP) = NTRUNTRU (IF,NIF) = NTRUNTRU (IF,NTRU) = NTRUNTRU (IF,AND) = NTRUNTRU (IF,NIMP) = NTRUNTRU (IF,XOR) = NTRUNTRU (IF,IMP) = NTRUNTRU (IF,NAND) = NTRUNTRU (IF,TRU) = NTRUNTRU (IF,IF) = NTRUNTRU (IF,FIX) = NTRUNTRU (IF,LET) = NTRUNTRU (IF,NOR) = NTRUNTRU (FIX,LEQ) = NTRUNTRU (FIX,OR) = NTRUNTRU (FIX,DENY) = NTRUNTRU (FIX,FLIP) = NTRUNTRU (FIX,NIF) = NTRUNTRU (FIX,NTRU) = NTRUNTRU (FIX,AND) = NTRUNTRU (FIX,NIMP) = NTRUNTRU (FIX,XOR) = NTRUNTRU (FIX,IMP) = NTRUNTRU (FIX,NAND) = NTRUNTRU (FIX,TRU) = NTRUNTRU (FIX,IF) = NTRUNTRU (FIX,FIX) = NTRUNTRU (FIX,LET) = NTRUNTRU (FIX,NOR) = NTRUNTRU (LET,LEQ) = NTRUNTRU (LET,OR) = NTRUNTRU (LET,DENY) = NTRUNTRU (LET,FLIP) = NTRUNTRU (LET,NIF) = NTRUNTRU (LET,NTRU) = NTRUNTRU (LET,AND) = NTRUNTRU (LET,NIMP) = NTRUNTRU (LET,XOR) = NTRUNTRU (LET,IMP) = NTRUNTRU (LET,NAND) = NTRUNTRU (LET,TRU) = NTRUNTRU (LET,IF) = NTRUNTRU (LET,FIX) = NTRUNTRU (LET,LET) = NTRUNTRU (LET,NOR) = NTRUNTRU (NOR,LEQ) = NTRUNTRU (NOR,OR) = NTRUNTRU (NOR,DENY) = NTRUNTRU (NOR,FLIP) = NTRUNTRU (NOR,NIF) = NTRUNTRU (NOR,NTRU) = NTRUNTRU (NOR,AND) = NTRUNTRU (NOR,NIMP) = NTRUNTRU (NOR,XOR) = NTRUNTRU (NOR,IMP) = NTRUNTRU (NOR,NAND) = NTRUNTRU (NOR,TRU) = NTRUNTRU (NOR,IF) = NTRUNTRU (NOR,FIX) = NTRUNTRU (NOR,LET) = NTRUNTRU (NOR,NOR) = NTRUAND (LEQ,LEQ) = LEQAND (LEQ,OR) = ANDAND (LEQ,DENY) = NORAND (LEQ,FLIP) = NORAND (LEQ,NIF) = NTRUAND (LEQ,NTRU) = NTRUAND (LEQ,AND) = ANDAND (LEQ,NIMP) = NTRUAND (LEQ,XOR) = NTRUAND (LEQ,IMP) = LEQAND (LEQ,NAND) = NORAND (LEQ,TRU) = LEQAND (LEQ,IF) = LEQAND (LEQ,FIX) = ANDAND (LEQ,LET) = ANDAND (LEQ,NOR) = NORAND (OR,LEQ) = ANDAND (OR,OR) = ORAND (OR,DENY) = NIMPAND (OR,FLIP) = NIFAND (OR,NIF) = NIFAND (OR,NTRU) = NTRUAND (OR,AND) = ANDAND (OR,NIMP) = NIMPAND (OR,XOR) = XORAND (OR,IMP) = LETAND (OR,NAND) = XORAND (OR,TRU) = ORAND (OR,IF) = FIXAND (OR,FIX) = FIXAND (OR,LET) = LETAND (OR,NOR) = NTRUAND (DENY,LEQ) = NORAND (DENY,OR) = NIMPAND (DENY,DENY) = DENYAND (DENY,FLIP) = NORAND (DENY,NIF) = NTRUAND (DENY,NTRU) = NTRUAND (DENY,AND) = NTRUAND (DENY,NIMP) = NIMPAND (DENY,XOR) = NIMPAND (DENY,IMP) = NORAND (DENY,NAND) = DENYAND (DENY,TRU) = DENYAND (DENY,IF) = DENYAND (DENY,FIX) = NIMPAND (DENY,LET) = NTRUAND (DENY,NOR) = NORAND (FLIP,LEQ) = NORAND (FLIP,OR) = NIFAND (FLIP,DENY) = NORAND (FLIP,FLIP) = FLIPAND (FLIP,NIF) = NIFAND (FLIP,NTRU) = NTRUAND (FLIP,AND) = NTRUAND (FLIP,NIMP) = NTRUAND (FLIP,XOR) = NIFAND (FLIP,IMP) = FLIPAND (FLIP,NAND) = FLIPAND (FLIP,TRU) = FLIPAND (FLIP,IF) = NORAND (FLIP,FIX) = NTRUAND (FLIP,LET) = NIFAND (FLIP,NOR) = NORAND (NIF,LEQ) = NTRUAND (NIF,OR) = NIFAND (NIF,DENY) = NTRUAND (NIF,FLIP) = NIFAND (NIF,NIF) = NIFAND (NIF,NTRU) = NTRUAND (NIF,AND) = NTRUAND (NIF,NIMP) = NTRUAND (NIF,XOR) = NIFAND (NIF,IMP) = NIFAND (NIF,NAND) = NIFAND (NIF,TRU) = NIFAND (NIF,IF) = NTRUAND (NIF,FIX) = NTRUAND (NIF,LET) = NIFAND (NIF,NOR) = NTRUAND (NTRU,LEQ) = NTRUAND (NTRU,OR) = NTRUAND (NTRU,DENY) = NTRUAND (NTRU,FLIP) = NTRUAND (NTRU,NIF) = NTRUAND (NTRU,NTRU) = NTRUAND (NTRU,AND) = NTRUAND (NTRU,NIMP) = NTRUAND (NTRU,XOR) = NTRUAND (NTRU,IMP) = NTRUAND (NTRU,NAND) = NTRUAND (NTRU,TRU) = NTRUAND (NTRU,IF) = NTRUAND (NTRU,FIX) = NTRUAND (NTRU,LET) = NTRUAND (NTRU,NOR) = NTRUAND (AND,LEQ) = ANDAND (AND,OR) = ANDAND (AND,DENY) = NTRUAND (AND,FLIP) = NTRUAND (AND,NIF) = NTRUAND (AND,NTRU) = NTRUAND (AND,AND) = ANDAND (AND,NIMP) = NTRUAND (AND,XOR) = NTRUAND (AND,IMP) = ANDAND (AND,NAND) = NTRUAND (AND,TRU) = ANDAND (AND,IF) = ANDAND (AND,FIX) = ANDAND (AND,LET) = ANDAND (AND,NOR) = NTRUAND (NIMP,LEQ) = NTRUAND (NIMP,OR) = NIMPAND (NIMP,DENY) = NIMPAND (NIMP,FLIP) = NTRUAND (NIMP,NIF) = NTRUAND (NIMP,NTRU) = NTRUAND (NIMP,AND) = NTRUAND (NIMP,NIMP) = NIMPAND (NIMP,XOR) = NIMPAND (NIMP,IMP) = NTRUAND (NIMP,NAND) = NIMPAND (NIMP,TRU) = NIMPAND (NIMP,IF) = NIMPAND (NIMP,FIX) = NIMPAND (NIMP,LET) = NTRUAND (NIMP,NOR) = NTRUAND (XOR,LEQ) = NTRUAND (XOR,OR) = XORAND (XOR,DENY) = NIMPAND (XOR,FLIP) = NIFAND (XOR,NIF) = NIFAND (XOR,NTRU) = NTRUAND (XOR,AND) = NTRUAND (XOR,NIMP) = NIMPAND (XOR,XOR) = XORAND (XOR,IMP) = NIFAND (XOR,NAND) = XORAND (XOR,TRU) = XORAND (XOR,IF) = NIMPAND (XOR,FIX) = NIMPAND (XOR,LET) = NIFAND (XOR,NOR) = NTRUAND (IMP,LEQ) = LEQAND (IMP,OR) = LETAND (IMP,DENY) = NORAND (IMP,FLIP) = FLIPAND (IMP,NIF) = NIFAND (IMP,NTRU) = NTRUAND (IMP,AND) = ANDAND (IMP,NIMP) = NTRUAND (IMP,XOR) = NIFAND (IMP,IMP) = IMPAND (IMP,NAND) = FLIPAND (IMP,TRU) = IMPAND (IMP,IF) = LEQAND (IMP,FIX) = ANDAND (IMP,LET) = LETAND (IMP,NOR) = NORAND (NAND,LEQ) = NORAND (NAND,OR) = XORAND (NAND,DENY) = DENYAND (NAND,FLIP) = FLIPAND (NAND,NIF) = NIFAND (NAND,NTRU) = NTRUAND (NAND,AND) = NTRUAND (NAND,NIMP) = NIMPAND (NAND,XOR) = XORAND (NAND,IMP) = FLIPAND (NAND,NAND) = NANDAND (NAND,TRU) = NANDAND (NAND,IF) = DENYAND (NAND,FIX) = NIMPAND (NAND,LET) = NIFAND (NAND,NOR) = NORAND (TRU,LEQ) = LEQAND (TRU,OR) = ORAND (TRU,DENY) = DENYAND (TRU,FLIP) = FLIPAND (TRU,NIF) = NIFAND (TRU,NTRU) = NTRUAND (TRU,AND) = ANDAND (TRU,NIMP) = NIMPAND (TRU,XOR) = XORAND (TRU,IMP) = IMPAND (TRU,NAND) = NANDAND (TRU,TRU) = TRUAND (TRU,IF) = IFAND (TRU,FIX) = FIXAND (TRU,LET) = LETAND (TRU,NOR) = NORAND (IF,LEQ) = LEQAND (IF,OR) = FIXAND (IF,DENY) = DENYAND (IF,FLIP) = NORAND (IF,NIF) = NTRUAND (IF,NTRU) = NTRUAND (IF,AND) = ANDAND (IF,NIMP) = NIMPAND (IF,XOR) = NIMPAND (IF,IMP) = LEQAND (IF,NAND) = DENYAND (IF,TRU) = IFAND (IF,IF) = IFAND (IF,FIX) = FIXAND (IF,LET) = ANDAND (IF,NOR) = NORAND (FIX,LEQ) = ANDAND (FIX,OR) = FIXAND (FIX,DENY) = NIMPAND (FIX,FLIP) = NTRUAND (FIX,NIF) = NTRUAND (FIX,NTRU) = NTRUAND (FIX,AND) = ANDAND (FIX,NIMP) = NIMPAND (FIX,XOR) = NIMPAND (FIX,IMP) = ANDAND (FIX,NAND) = NIMPAND (FIX,TRU) = FIXAND (FIX,IF) = FIXAND (FIX,FIX) = FIXAND (FIX,LET) = ANDAND (FIX,NOR) = NTRUAND (LET,LEQ) = ANDAND (LET,OR) = LETAND (LET,DENY) = NTRUAND (LET,FLIP) = NIFAND (LET,NIF) = NIFAND (LET,NTRU) = NTRUAND (LET,AND) = ANDAND (LET,NIMP) = NTRUAND (LET,XOR) = NIFAND (LET,IMP) = LETAND (LET,NAND) = NIFAND (LET,TRU) = LETAND (LET,IF) = ANDAND (LET,FIX) = ANDAND (LET,LET) = LETAND (LET,NOR) = NTRUAND (NOR,LEQ) = NORAND (NOR,OR) = NTRUAND (NOR,DENY) = NORAND (NOR,FLIP) = NORAND (NOR,NIF) = NTRUAND (NOR,NTRU) = NTRUAND (NOR,AND) = NTRUAND (NOR,NIMP) = NTRUAND (NOR,XOR) = NTRUAND (NOR,IMP) = NORAND (NOR,NAND) = NORAND (NOR,TRU) = NORAND (NOR,IF) = NORAND (NOR,FIX) = NTRUAND (NOR,LET) = NTRUAND (NOR,NOR) = NORNIMP (LEQ,LEQ) = NTRUNIMP (LEQ,OR) = NORNIMP (LEQ,DENY) = ANDNIMP (LEQ,FLIP) = ANDNIMP (LEQ,NIF) = LEQNIMP (LEQ,NTRU) = LEQNIMP (LEQ,AND) = NORNIMP (LEQ,NIMP) = LEQNIMP (LEQ,XOR) = LEQNIMP (LEQ,IMP) = NTRUNIMP (LEQ,NAND) = ANDNIMP (LEQ,TRU) = NTRUNIMP (LEQ,IF) = NTRUNIMP (LEQ,FIX) = NORNIMP (LEQ,LET) = NORNIMP (LEQ,NOR) = ANDNIMP (OR,LEQ) = XORNIMP (OR,OR) = NTRUNIMP (OR,DENY) = LETNIMP (OR,FLIP) = FIXNIMP (OR,NIF) = FIXNIMP (OR,NTRU) = ORNIMP (OR,AND) = XORNIMP (OR,NIMP) = LETNIMP (OR,XOR) = ANDNIMP (OR,IMP) = NIMPNIMP (OR,NAND) = ANDNIMP (OR,TRU) = NTRUNIMP (OR,IF) = NIFNIMP (OR,FIX) = NIFNIMP (OR,LET) = NIMPNIMP (OR,NOR) = ORNIMP (DENY,LEQ) = NIMPNIMP (DENY,OR) = NORNIMP (DENY,DENY) = NTRUNIMP (DENY,FLIP) = NIMPNIMP (DENY,NIF) = DENYNIMP (DENY,NTRU) = DENYNIMP (DENY,AND) = DENYNIMP (DENY,NIMP) = NORNIMP (DENY,XOR) = NORNIMP (DENY,IMP) = NIMPNIMP (DENY,NAND) = NTRUNIMP (DENY,TRU) = NTRUNIMP (DENY,IF) = NTRUNIMP (DENY,FIX) = NORNIMP (DENY,LET) = DENYNIMP (DENY,NOR) = NIMPNIMP (FLIP,LEQ) = NIFNIMP (FLIP,OR) = NORNIMP (FLIP,DENY) = NIFNIMP (FLIP,FLIP) = NTRUNIMP (FLIP,NIF) = NORNIMP (FLIP,NTRU) = FLIPNIMP (FLIP,AND) = FLIPNIMP (FLIP,NIMP) = FLIPNIMP (FLIP,XOR) = NORNIMP (FLIP,IMP) = NTRUNIMP (FLIP,NAND) = NTRUNIMP (FLIP,TRU) = NTRUNIMP (FLIP,IF) = NIFNIMP (FLIP,FIX) = FLIPNIMP (FLIP,LET) = NORNIMP (FLIP,NOR) = NIFNIMP (NIF,LEQ) = NIFNIMP (NIF,OR) = NTRUNIMP (NIF,DENY) = NIFNIMP (NIF,FLIP) = NTRUNIMP (NIF,NIF) = NTRUNIMP (NIF,NTRU) = NIFNIMP (NIF,AND) = NIFNIMP (NIF,NIMP) = NIFNIMP (NIF,XOR) = NTRUNIMP (NIF,IMP) = NTRUNIMP (NIF,NAND) = NTRUNIMP (NIF,TRU) = NTRUNIMP (NIF,IF) = NIFNIMP (NIF,FIX) = NIFNIMP (NIF,LET) = NTRUNIMP (NIF,NOR) = NIFNIMP (NTRU,LEQ) = NTRUNIMP (NTRU,OR) = NTRUNIMP (NTRU,DENY) = NTRUNIMP (NTRU,FLIP) = NTRUNIMP (NTRU,NIF) = NTRUNIMP (NTRU,NTRU) = NTRUNIMP (NTRU,AND) = NTRUNIMP (NTRU,NIMP) = NTRUNIMP (NTRU,XOR) = NTRUNIMP (NTRU,IMP) = NTRUNIMP (NTRU,NAND) = NTRUNIMP (NTRU,TRU) = NTRUNIMP (NTRU,IF) = NTRUNIMP (NTRU,FIX) = NTRUNIMP (NTRU,LET) = NTRUNIMP (NTRU,NOR) = NTRUNIMP (AND,LEQ) = NTRUNIMP (AND,OR) = NTRUNIMP (AND,DENY) = ANDNIMP (AND,FLIP) = ANDNIMP (AND,NIF) = ANDNIMP (AND,NTRU) = ANDNIMP (AND,AND) = NTRUNIMP (AND,NIMP) = ANDNIMP (AND,XOR) = ANDNIMP (AND,IMP) = NTRUNIMP (AND,NAND) = ANDNIMP (AND,TRU) = NTRUNIMP (AND,IF) = NTRUNIMP (AND,FIX) = NTRUNIMP (AND,LET) = NTRUNIMP (AND,NOR) = ANDNIMP (NIMP,LEQ) = NIMPNIMP (NIMP,OR) = NTRUNIMP (NIMP,DENY) = NTRUNIMP (NIMP,FLIP) = NIMPNIMP (NIMP,NIF) = NIMPNIMP (NIMP,NTRU) = NIMPNIMP (NIMP,AND) = NIMPNIMP (NIMP,NIMP) = NTRUNIMP (NIMP,XOR) = NTRUNIMP (NIMP,IMP) = NIMPNIMP (NIMP,NAND) = NTRUNIMP (NIMP,TRU) = NTRUNIMP (NIMP,IF) = NTRUNIMP (NIMP,FIX) = NTRUNIMP (NIMP,LET) = NIMPNIMP (NIMP,NOR) = NIMPNIMP (XOR,LEQ) = XORNIMP (XOR,OR) = NTRUNIMP (XOR,DENY) = NIFNIMP (XOR,FLIP) = NIMPNIMP (XOR,NIF) = NIMPNIMP (XOR,NTRU) = XORNIMP (XOR,AND) = XORNIMP (XOR,NIMP) = NIFNIMP (XOR,XOR) = NTRUNIMP (XOR,IMP) = NIMPNIMP (XOR,NAND) = NTRUNIMP (XOR,TRU) = NTRUNIMP (XOR,IF) = NIFNIMP (XOR,FIX) = NIFNIMP (XOR,LET) = NIMPNIMP (XOR,NOR) = XORNIMP (IMP,LEQ) = NIFNIMP (IMP,OR) = NORNIMP (IMP,DENY) = LETNIMP (IMP,FLIP) = ANDNIMP (IMP,NIF) = LEQNIMP (IMP,NTRU) = IMPNIMP (IMP,AND) = FLIPNIMP (IMP,NIMP) = IMPNIMP (IMP,XOR) = LEQNIMP (IMP,IMP) = NTRUNIMP (IMP,NAND) = ANDNIMP (IMP,TRU) = NTRUNIMP (IMP,IF) = NIFNIMP (IMP,FIX) = FLIPNIMP (IMP,LET) = NORNIMP (IMP,NOR) = LETNIMP (NAND,LEQ) = XORNIMP (NAND,OR) = NORNIMP (NAND,DENY) = NIFNIMP (NAND,FLIP) = NIMPNIMP (NAND,NIF) = DENYNIMP (NAND,NTRU) = NANDNIMP (NAND,AND) = NANDNIMP (NAND,NIMP) = FLIPNIMP (NAND,XOR) = NORNIMP (NAND,IMP) = NIMPNIMP (NAND,NAND) = NTRUNIMP (NAND,TRU) = NTRUNIMP (NAND,IF) = NIFNIMP (NAND,FIX) = FLIPNIMP (NAND,LET) = DENYNIMP (NAND,NOR) = XORNIMP (TRU,LEQ) = XORNIMP (TRU,OR) = NORNIMP (TRU,DENY) = LETNIMP (TRU,FLIP) = FIXNIMP (TRU,NIF) = IFNIMP (TRU,NTRU) = TRUNIMP (TRU,AND) = NANDNIMP (TRU,NIMP) = IMPNIMP (TRU,XOR) = LEQNIMP (TRU,IMP) = NIMPNIMP (TRU,NAND) = ANDNIMP (TRU,TRU) = NTRUNIMP (TRU,IF) = NIFNIMP (TRU,FIX) = FLIPNIMP (TRU,LET) = DENYNIMP (TRU,NOR) = ORNIMP (IF,LEQ) = NIMPNIMP (IF,OR) = NORNIMP (IF,DENY) = ANDNIMP (IF,FLIP) = FIXNIMP (IF,NIF) = IFNIMP (IF,NTRU) = IFNIMP (IF,AND) = DENYNIMP (IF,NIMP) = LEQNIMP (IF,XOR) = LEQNIMP (IF,IMP) = NIMPNIMP (IF,NAND) = ANDNIMP (IF,TRU) = NTRUNIMP (IF,IF) = NTRUNIMP (IF,FIX) = NORNIMP (IF,LET) = DENYNIMP (IF,NOR) = FIXNIMP (FIX,LEQ) = NIMPNIMP (FIX,OR) = NTRUNIMP (FIX,DENY) = ANDNIMP (FIX,FLIP) = FIXNIMP (FIX,NIF) = FIXNIMP (FIX,NTRU) = FIXNIMP (FIX,AND) = NIMPNIMP (FIX,NIMP) = ANDNIMP (FIX,XOR) = ANDNIMP (FIX,IMP) = NIMPNIMP (FIX,NAND) = ANDNIMP (FIX,TRU) = NTRUNIMP (FIX,IF) = NTRUNIMP (FIX,FIX) = NTRUNIMP (FIX,LET) = NIMPNIMP (FIX,NOR) = FIXNIMP (LET,LEQ) = NIFNIMP (LET,OR) = NTRUNIMP (LET,DENY) = LETNIMP (LET,FLIP) = ANDNIMP (LET,NIF) = ANDNIMP (LET,NTRU) = LETNIMP (LET,AND) = NIFNIMP (LET,NIMP) = LETNIMP (LET,XOR) = ANDNIMP (LET,IMP) = NTRUNIMP (LET,NAND) = ANDNIMP (LET,TRU) = NTRUNIMP (LET,IF) = NIFNIMP (LET,FIX) = NIFNIMP (LET,LET) = NTRUNIMP (LET,NOR) = LETNIMP (NOR,LEQ) = NTRUNIMP (NOR,OR) = NORNIMP (NOR,DENY) = NTRUNIMP (NOR,FLIP) = NTRUNIMP (NOR,NIF) = NORNIMP (NOR,NTRU) = NORNIMP (NOR,AND) = NORNIMP (NOR,NIMP) = NORNIMP (NOR,XOR) = NORNIMP (NOR,IMP) = NTRUNIMP (NOR,NAND) = NTRUNIMP (NOR,TRU) = NTRUNIMP (NOR,IF) = NTRUNIMP (NOR,FIX) = NORNIMP (NOR,LET) = NORNIMP (NOR,NOR) = NTRUXOR (LEQ,LEQ) = NTRUXOR (LEQ,OR) = NANDXOR (LEQ,DENY) = FIXXOR (LEQ,FLIP) = LETXOR (LEQ,NIF) = IMPXOR (LEQ,NTRU) = LEQXOR (LEQ,AND) = NORXOR (LEQ,NIMP) = IFXOR (LEQ,XOR) = TRUXOR (LEQ,IMP) = NIFXOR (LEQ,NAND) = ORXOR (LEQ,TRU) = XORXOR (LEQ,IF) = NIMPXOR (LEQ,FIX) = DENYXOR (LEQ,LET) = FLIPXOR (LEQ,NOR) = ANDXOR (OR,LEQ) = NANDXOR (OR,OR) = NTRUXOR (OR,DENY) = IMPXOR (OR,FLIP) = IFXOR (OR,NIF) = FIXXOR (OR,NTRU) = ORXOR (OR,AND) = XORXOR (OR,NIMP) = LETXOR (OR,XOR) = ANDXOR (OR,IMP) = DENYXOR (OR,NAND) = LEQXOR (OR,TRU) = NORXOR (OR,IF) = FLIPXOR (OR,FIX) = NIFXOR (OR,LET) = NIMPXOR (OR,NOR) = TRUXOR (DENY,LEQ) = FIXXOR (DENY,OR) = IMPXOR (DENY,DENY) = NTRUXOR (DENY,FLIP) = XORXOR (DENY,NIF) = NANDXOR (DENY,NTRU) = DENYXOR (DENY,AND) = IFXOR (DENY,NIMP) = NORXOR (DENY,XOR) = FLIPXOR (DENY,IMP) = ORXOR (DENY,NAND) = NIFXOR (DENY,TRU) = LETXOR (DENY,IF) = ANDXOR (DENY,FIX) = LEQXOR (DENY,LET) = TRUXOR (DENY,NOR) = NIMPXOR (FLIP,LEQ) = LETXOR (FLIP,OR) = IFXOR (FLIP,DENY) = XORXOR (FLIP,FLIP) = NTRUXOR (FLIP,NIF) = NORXOR (FLIP,NTRU) = FLIPXOR (FLIP,AND) = IMPXOR (FLIP,NIMP) = NANDXOR (FLIP,XOR) = DENYXOR (FLIP,IMP) = ANDXOR (FLIP,NAND) = NIMPXOR (FLIP,TRU) = FIXXOR (FLIP,IF) = ORXOR (FLIP,FIX) = TRUXOR (FLIP,LET) = LEQXOR (FLIP,NOR) = NIFXOR (NIF,LEQ) = IMPXOR (NIF,OR) = FIXXOR (NIF,DENY) = NANDXOR (NIF,FLIP) = NORXOR (NIF,NIF) = NTRUXOR (NIF,NTRU) = NIFXOR (NIF,AND) = LETXOR (NIF,NIMP) = XORXOR (NIF,XOR) = NIMPXOR (NIF,IMP) = LEQXOR (NIF,NAND) = DENYXOR (NIF,TRU) = IFXOR (NIF,IF) = TRUXOR (NIF,FIX) = ORXOR (NIF,LET) = ANDXOR (NIF,NOR) = FLIPXOR (NTRU,LEQ) = LEQXOR (NTRU,OR) = ORXOR (NTRU,DENY) = DENYXOR (NTRU,FLIP) = FLIPXOR (NTRU,NIF) = NIFXOR (NTRU,NTRU) = NTRUXOR (NTRU,AND) = ANDXOR (NTRU,NIMP) = NIMPXOR (NTRU,XOR) = XORXOR (NTRU,IMP) = IMPXOR (NTRU,NAND) = NANDXOR (NTRU,TRU) = TRUXOR (NTRU,IF) = IFXOR (NTRU,FIX) = FIXXOR (NTRU,LET) = LETXOR (NTRU,NOR) = NORXOR (AND,LEQ) = NORXOR (AND,OR) = XORXOR (AND,DENY) = IFXOR (AND,FLIP) = IMPXOR (AND,NIF) = LETXOR (AND,NTRU) = ANDXOR (AND,AND) = NTRUXOR (AND,NIMP) = FIXXOR (AND,XOR) = ORXOR (AND,IMP) = FLIPXOR (AND,NAND) = TRUXOR (AND,TRU) = NANDXOR (AND,IF) = DENYXOR (AND,FIX) = NIMPXOR (AND,LET) = NIFXOR (AND,NOR) = LEQXOR (NIMP,LEQ) = IFXOR (NIMP,OR) = LETXOR (NIMP,DENY) = NORXOR (NIMP,FLIP) = NANDXOR (NIMP,NIF) = XORXOR (NIMP,NTRU) = NIMPXOR (NIMP,AND) = FIXXOR (NIMP,NIMP) = NTRUXOR (NIMP,XOR) = NIFXOR (NIMP,IMP) = TRUXOR (NIMP,NAND) = FLIPXOR (NIMP,TRU) = IMPXOR (NIMP,IF) = LEQXOR (NIMP,FIX) = ANDXOR (NIMP,LET) = ORXOR (NIMP,NOR) = DENYXOR (XOR,LEQ) = TRUXOR (XOR,OR) = ANDXOR (XOR,DENY) = FLIPXOR (XOR,FLIP) = DENYXOR (XOR,NIF) = NIMPXOR (XOR,NTRU) = XORXOR (XOR,AND) = ORXOR (XOR,NIMP) = NIFXOR (XOR,XOR) = NTRUXOR (XOR,IMP) = IFXOR (XOR,NAND) = NORXOR (XOR,TRU) = LEQXOR (XOR,IF) = IMPXOR (XOR,FIX) = LETXOR (XOR,LET) = FIXXOR (XOR,NOR) = NANDXOR (IMP,LEQ) = NIFXOR (IMP,OR) = DENYXOR (IMP,DENY) = ORXOR (IMP,FLIP) = ANDXOR (IMP,NIF) = LEQXOR (IMP,NTRU) = IMPXOR (IMP,AND) = FLIPXOR (IMP,NIMP) = TRUXOR (IMP,XOR) = IFXOR (IMP,IMP) = NTRUXOR (IMP,NAND) = FIXXOR (IMP,TRU) = NIMPXOR (IMP,IF) = XORXOR (IMP,FIX) = NANDXOR (IMP,LET) = NORXOR (IMP,NOR) = LETXOR (NAND,LEQ) = ORXOR (NAND,OR) = LEQXOR (NAND,DENY) = NIFXOR (NAND,FLIP) = NIMPXOR (NAND,NIF) = DENYXOR (NAND,NTRU) = NANDXOR (NAND,AND) = TRUXOR (NAND,NIMP) = FLIPXOR (NAND,XOR) = NORXOR (NAND,IMP) = FIXXOR (NAND,NAND) = NTRUXOR (NAND,TRU) = ANDXOR (NAND,IF) = LETXOR (NAND,FIX) = IMPXOR (NAND,LET) = IFXOR (NAND,NOR) = XORXOR (TRU,LEQ) = XORXOR (TRU,OR) = NORXOR (TRU,DENY) = LETXOR (TRU,FLIP) = FIXXOR (TRU,NIF) = IFXOR (TRU,NTRU) = TRUXOR (TRU,AND) = NANDXOR (TRU,NIMP) = IMPXOR (TRU,XOR) = LEQXOR (TRU,IMP) = NIMPXOR (TRU,NAND) = ANDXOR (TRU,TRU) = NTRUXOR (TRU,IF) = NIFXOR (TRU,FIX) = FLIPXOR (TRU,LET) = DENYXOR (TRU,NOR) = ORXOR (IF,LEQ) = NIMPXOR (IF,OR) = FLIPXOR (IF,DENY) = ANDXOR (IF,FLIP) = ORXOR (IF,NIF) = TRUXOR (IF,NTRU) = IFXOR (IF,AND) = DENYXOR (IF,NIMP) = LEQXOR (IF,XOR) = IMPXOR (IF,IMP) = XORXOR (IF,NAND) = LETXOR (IF,TRU) = NIFXOR (IF,IF) = NTRUXOR (IF,FIX) = NORXOR (IF,LET) = NANDXOR (IF,NOR) = FIXXOR (FIX,LEQ) = DENYXOR (FIX,OR) = NIFXOR (FIX,DENY) = LEQXOR (FIX,FLIP) = TRUXOR (FIX,NIF) = ORXOR (FIX,NTRU) = FIXXOR (FIX,AND) = NIMPXOR (FIX,NIMP) = ANDXOR (FIX,XOR) = LETXOR (FIX,IMP) = NANDXOR (FIX,NAND) = IMPXOR (FIX,TRU) = FLIPXOR (FIX,IF) = NORXOR (FIX,FIX) = NTRUXOR (FIX,LET) = XORXOR (FIX,NOR) = IFXOR (LET,LEQ) = FLIPXOR (LET,OR) = NIMPXOR (LET,DENY) = TRUXOR (LET,FLIP) = LEQXOR (LET,NIF) = ANDXOR (LET,NTRU) = LETXOR (LET,AND) = NIFXOR (LET,NIMP) = ORXOR (LET,XOR) = FIXXOR (LET,IMP) = NORXOR (LET,NAND) = IFXOR (LET,TRU) = DENYXOR (LET,IF) = NANDXOR (LET,FIX) = XORXOR (LET,LET) = NTRUXOR (LET,NOR) = IMPXOR (NOR,LEQ) = ANDXOR (NOR,OR) = TRUXOR (NOR,DENY) = NIMPXOR (NOR,FLIP) = NIFXOR (NOR,NIF) = FLIPXOR (NOR,NTRU) = NORXOR (NOR,AND) = LEQXOR (NOR,NIMP) = DENYXOR (NOR,XOR) = NANDXOR (NOR,IMP) = LETXOR (NOR,NAND) = XORXOR (NOR,TRU) = ORXOR (NOR,IF) = FIXXOR (NOR,FIX) = IFXOR (NOR,LET) = IMPXOR (NOR,NOR) = NTRUIMP (LEQ,LEQ) = TRUIMP (LEQ,OR) = ORIMP (LEQ,DENY) = NANDIMP (LEQ,FLIP) = NANDIMP (LEQ,NIF) = XORIMP (LEQ,NTRU) = XORIMP (LEQ,AND) = ORIMP (LEQ,NIMP) = XORIMP (LEQ,XOR) = XORIMP (LEQ,IMP) = TRUIMP (LEQ,NAND) = NANDIMP (LEQ,TRU) = TRUIMP (LEQ,IF) = TRUIMP (LEQ,FIX) = ORIMP (LEQ,LET) = ORIMP (LEQ,NOR) = NANDIMP (OR,LEQ) = LEQIMP (OR,OR) = TRUIMP (OR,DENY) = DENYIMP (OR,FLIP) = FLIPIMP (OR,NIF) = FLIPIMP (OR,NTRU) = NORIMP (OR,AND) = LEQIMP (OR,NIMP) = DENYIMP (OR,XOR) = NANDIMP (OR,IMP) = IMPIMP (OR,NAND) = NANDIMP (OR,TRU) = TRUIMP (OR,IF) = IFIMP (OR,FIX) = IFIMP (OR,LET) = IMPIMP (OR,NOR) = NORIMP (DENY,LEQ) = IMPIMP (DENY,OR) = ORIMP (DENY,DENY) = TRUIMP (DENY,FLIP) = IMPIMP (DENY,NIF) = LETIMP (DENY,NTRU) = LETIMP (DENY,AND) = LETIMP (DENY,NIMP) = ORIMP (DENY,XOR) = ORIMP (DENY,IMP) = IMPIMP (DENY,NAND) = TRUIMP (DENY,TRU) = TRUIMP (DENY,IF) = TRUIMP (DENY,FIX) = ORIMP (DENY,LET) = LETIMP (DENY,NOR) = IMPIMP (FLIP,LEQ) = IFIMP (FLIP,OR) = ORIMP (FLIP,DENY) = IFIMP (FLIP,FLIP) = TRUIMP (FLIP,NIF) = ORIMP (FLIP,NTRU) = FIXIMP (FLIP,AND) = FIXIMP (FLIP,NIMP) = FIXIMP (FLIP,XOR) = ORIMP (FLIP,IMP) = TRUIMP (FLIP,NAND) = TRUIMP (FLIP,TRU) = TRUIMP (FLIP,IF) = IFIMP (FLIP,FIX) = FIXIMP (FLIP,LET) = ORIMP (FLIP,NOR) = IFIMP (NIF,LEQ) = IFIMP (NIF,OR) = TRUIMP (NIF,DENY) = IFIMP (NIF,FLIP) = TRUIMP (NIF,NIF) = TRUIMP (NIF,NTRU) = IFIMP (NIF,AND) = IFIMP (NIF,NIMP) = IFIMP (NIF,XOR) = TRUIMP (NIF,IMP) = TRUIMP (NIF,NAND) = TRUIMP (NIF,TRU) = TRUIMP (NIF,IF) = IFIMP (NIF,FIX) = IFIMP (NIF,LET) = TRUIMP (NIF,NOR) = IFIMP (NTRU,LEQ) = TRUIMP (NTRU,OR) = TRUIMP (NTRU,DENY) = TRUIMP (NTRU,FLIP) = TRUIMP (NTRU,NIF) = TRUIMP (NTRU,NTRU) = TRUIMP (NTRU,AND) = TRUIMP (NTRU,NIMP) = TRUIMP (NTRU,XOR) = TRUIMP (NTRU,IMP) = TRUIMP (NTRU,NAND) = TRUIMP (NTRU,TRU) = TRUIMP (NTRU,IF) = TRUIMP (NTRU,FIX) = TRUIMP (NTRU,LET) = TRUIMP (NTRU,NOR) = TRUIMP (AND,LEQ) = TRUIMP (AND,OR) = TRUIMP (AND,DENY) = NANDIMP (AND,FLIP) = NANDIMP (AND,NIF) = NANDIMP (AND,NTRU) = NANDIMP (AND,AND) = TRUIMP (AND,NIMP) = NANDIMP (AND,XOR) = NANDIMP (AND,IMP) = TRUIMP (AND,NAND) = NANDIMP (AND,TRU) = TRUIMP (AND,IF) = TRUIMP (AND,FIX) = TRUIMP (AND,LET) = TRUIMP (AND,NOR) = NANDIMP (NIMP,LEQ) = IMPIMP (NIMP,OR) = TRUIMP (NIMP,DENY) = TRUIMP (NIMP,FLIP) = IMPIMP (NIMP,NIF) = IMPIMP (NIMP,NTRU) = IMPIMP (NIMP,AND) = IMPIMP (NIMP,NIMP) = TRUIMP (NIMP,XOR) = TRUIMP (NIMP,IMP) = IMPIMP (NIMP,NAND) = TRUIMP (NIMP,TRU) = TRUIMP (NIMP,IF) = TRUIMP (NIMP,FIX) = TRUIMP (NIMP,LET) = IMPIMP (NIMP,NOR) = IMPIMP (XOR,LEQ) = LEQIMP (XOR,OR) = TRUIMP (XOR,DENY) = IFIMP (XOR,FLIP) = IMPIMP (XOR,NIF) = IMPIMP (XOR,NTRU) = LEQIMP (XOR,AND) = LEQIMP (XOR,NIMP) = IFIMP (XOR,XOR) = TRUIMP (XOR,IMP) = IMPIMP (XOR,NAND) = TRUIMP (XOR,TRU) = TRUIMP (XOR,IF) = IFIMP (XOR,FIX) = IFIMP (XOR,LET) = IMPIMP (XOR,NOR) = LEQIMP (IMP,LEQ) = IFIMP (IMP,OR) = ORIMP (IMP,DENY) = DENYIMP (IMP,FLIP) = NANDIMP (IMP,NIF) = XORIMP (IMP,NTRU) = NIMPIMP (IMP,AND) = FIXIMP (IMP,NIMP) = NIMPIMP (IMP,XOR) = XORIMP (IMP,IMP) = TRUIMP (IMP,NAND) = NANDIMP (IMP,TRU) = TRUIMP (IMP,IF) = IFIMP (IMP,FIX) = FIXIMP (IMP,LET) = ORIMP (IMP,NOR) = DENYIMP (NAND,LEQ) = LEQIMP (NAND,OR) = ORIMP (NAND,DENY) = IFIMP (NAND,FLIP) = IMPIMP (NAND,NIF) = LETIMP (NAND,NTRU) = ANDIMP (NAND,AND) = ANDIMP (NAND,NIMP) = FIXIMP (NAND,XOR) = ORIMP (NAND,IMP) = IMPIMP (NAND,NAND) = TRUIMP (NAND,TRU) = TRUIMP (NAND,IF) = IFIMP (NAND,FIX) = FIXIMP (NAND,LET) = LETIMP (NAND,NOR) = LEQIMP (TRU,LEQ) = LEQIMP (TRU,OR) = ORIMP (TRU,DENY) = DENYIMP (TRU,FLIP) = FLIPIMP (TRU,NIF) = NIFIMP (TRU,NTRU) = NTRUIMP (TRU,AND) = ANDIMP (TRU,NIMP) = NIMPIMP (TRU,XOR) = XORIMP (TRU,IMP) = IMPIMP (TRU,NAND) = NANDIMP (TRU,TRU) = TRUIMP (TRU,IF) = IFIMP (TRU,FIX) = FIXIMP (TRU,LET) = LETIMP (TRU,NOR) = NORIMP (IF,LEQ) = IMPIMP (IF,OR) = ORIMP (IF,DENY) = NANDIMP (IF,FLIP) = FLIPIMP (IF,NIF) = NIFIMP (IF,NTRU) = NIFIMP (IF,AND) = LETIMP (IF,NIMP) = XORIMP (IF,XOR) = XORIMP (IF,IMP) = IMPIMP (IF,NAND) = NANDIMP (IF,TRU) = TRUIMP (IF,IF) = TRUIMP (IF,FIX) = ORIMP (IF,LET) = LETIMP (IF,NOR) = FLIPIMP (FIX,LEQ) = IMPIMP (FIX,OR) = TRUIMP (FIX,DENY) = NANDIMP (FIX,FLIP) = FLIPIMP (FIX,NIF) = FLIPIMP (FIX,NTRU) = FLIPIMP (FIX,AND) = IMPIMP (FIX,NIMP) = NANDIMP (FIX,XOR) = NANDIMP (FIX,IMP) = IMPIMP (FIX,NAND) = NANDIMP (FIX,TRU) = TRUIMP (FIX,IF) = TRUIMP (FIX,FIX) = TRUIMP (FIX,LET) = IMPIMP (FIX,NOR) = FLIPIMP (LET,LEQ) = IFIMP (LET,OR) = TRUIMP (LET,DENY) = DENYIMP (LET,FLIP) = NANDIMP (LET,NIF) = NANDIMP (LET,NTRU) = DENYIMP (LET,AND) = IFIMP (LET,NIMP) = DENYIMP (LET,XOR) = NANDIMP (LET,IMP) = TRUIMP (LET,NAND) = NANDIMP (LET,TRU) = TRUIMP (LET,IF) = IFIMP (LET,FIX) = IFIMP (LET,LET) = TRUIMP (LET,NOR) = DENYIMP (NOR,LEQ) = TRUIMP (NOR,OR) = ORIMP (NOR,DENY) = TRUIMP (NOR,FLIP) = TRUIMP (NOR,NIF) = ORIMP (NOR,NTRU) = ORIMP (NOR,AND) = ORIMP (NOR,NIMP) = ORIMP (NOR,XOR) = ORIMP (NOR,IMP) = TRUIMP (NOR,NAND) = TRUIMP (NOR,TRU) = TRUIMP (NOR,IF) = TRUIMP (NOR,FIX) = ORIMP (NOR,LET) = ORIMP (NOR,NOR) = TRUNAND (LEQ,LEQ) = XORNAND (LEQ,OR) = NANDNAND (LEQ,DENY) = ORNAND (LEQ,FLIP) = ORNAND (LEQ,NIF) = TRUNAND (LEQ,NTRU) = TRUNAND (LEQ,AND) = NANDNAND (LEQ,NIMP) = TRUNAND (LEQ,XOR) = TRUNAND (LEQ,IMP) = XORNAND (LEQ,NAND) = ORNAND (LEQ,TRU) = XORNAND (LEQ,IF) = XORNAND (LEQ,FIX) = NANDNAND (LEQ,LET) = NANDNAND (LEQ,NOR) = ORNAND (OR,LEQ) = NANDNAND (OR,OR) = NORNAND (OR,DENY) = IMPNAND (OR,FLIP) = IFNAND (OR,NIF) = IFNAND (OR,NTRU) = TRUNAND (OR,AND) = NANDNAND (OR,NIMP) = IMPNAND (OR,XOR) = LEQNAND (OR,IMP) = DENYNAND (OR,NAND) = LEQNAND (OR,TRU) = NORNAND (OR,IF) = FLIPNAND (OR,FIX) = FLIPNAND (OR,LET) = DENYNAND (OR,NOR) = TRUNAND (DENY,LEQ) = ORNAND (DENY,OR) = IMPNAND (DENY,DENY) = LETNAND (DENY,FLIP) = ORNAND (DENY,NIF) = TRUNAND (DENY,NTRU) = TRUNAND (DENY,AND) = TRUNAND (DENY,NIMP) = IMPNAND (DENY,XOR) = IMPNAND (DENY,IMP) = ORNAND (DENY,NAND) = LETNAND (DENY,TRU) = LETNAND (DENY,IF) = LETNAND (DENY,FIX) = IMPNAND (DENY,LET) = TRUNAND (DENY,NOR) = ORNAND (FLIP,LEQ) = ORNAND (FLIP,OR) = IFNAND (FLIP,DENY) = ORNAND (FLIP,FLIP) = FIXNAND (FLIP,NIF) = IFNAND (FLIP,NTRU) = TRUNAND (FLIP,AND) = TRUNAND (FLIP,NIMP) = TRUNAND (FLIP,XOR) = IFNAND (FLIP,IMP) = FIXNAND (FLIP,NAND) = FIXNAND (FLIP,TRU) = FIXNAND (FLIP,IF) = ORNAND (FLIP,FIX) = TRUNAND (FLIP,LET) = IFNAND (FLIP,NOR) = ORNAND (NIF,LEQ) = TRUNAND (NIF,OR) = IFNAND (NIF,DENY) = TRUNAND (NIF,FLIP) = IFNAND (NIF,NIF) = IFNAND (NIF,NTRU) = TRUNAND (NIF,AND) = TRUNAND (NIF,NIMP) = TRUNAND (NIF,XOR) = IFNAND (NIF,IMP) = IFNAND (NIF,NAND) = IFNAND (NIF,TRU) = IFNAND (NIF,IF) = TRUNAND (NIF,FIX) = TRUNAND (NIF,LET) = IFNAND (NIF,NOR) = TRUNAND (NTRU,LEQ) = TRUNAND (NTRU,OR) = TRUNAND (NTRU,DENY) = TRUNAND (NTRU,FLIP) = TRUNAND (NTRU,NIF) = TRUNAND (NTRU,NTRU) = TRUNAND (NTRU,AND) = TRUNAND (NTRU,NIMP) = TRUNAND (NTRU,XOR) = TRUNAND (NTRU,IMP) = TRUNAND (NTRU,NAND) = TRUNAND (NTRU,TRU) = TRUNAND (NTRU,IF) = TRUNAND (NTRU,FIX) = TRUNAND (NTRU,LET) = TRUNAND (NTRU,NOR) = TRUNAND (AND,LEQ) = NANDNAND (AND,OR) = NANDNAND (AND,DENY) = TRUNAND (AND,FLIP) = TRUNAND (AND,NIF) = TRUNAND (AND,NTRU) = TRUNAND (AND,AND) = NANDNAND (AND,NIMP) = TRUNAND (AND,XOR) = TRUNAND (AND,IMP) = NANDNAND (AND,NAND) = TRUNAND (AND,TRU) = NANDNAND (AND,IF) = NANDNAND (AND,FIX) = NANDNAND (AND,LET) = NANDNAND (AND,NOR) = TRUNAND (NIMP,LEQ) = TRUNAND (NIMP,OR) = IMPNAND (NIMP,DENY) = IMPNAND (NIMP,FLIP) = TRUNAND (NIMP,NIF) = TRUNAND (NIMP,NTRU) = TRUNAND (NIMP,AND) = TRUNAND (NIMP,NIMP) = IMPNAND (NIMP,XOR) = IMPNAND (NIMP,IMP) = TRUNAND (NIMP,NAND) = IMPNAND (NIMP,TRU) = IMPNAND (NIMP,IF) = IMPNAND (NIMP,FIX) = IMPNAND (NIMP,LET) = TRUNAND (NIMP,NOR) = TRUNAND (XOR,LEQ) = TRUNAND (XOR,OR) = LEQNAND (XOR,DENY) = IMPNAND (XOR,FLIP) = IFNAND (XOR,NIF) = IFNAND (XOR,NTRU) = TRUNAND (XOR,AND) = TRUNAND (XOR,NIMP) = IMPNAND (XOR,XOR) = LEQNAND (XOR,IMP) = IFNAND (XOR,NAND) = LEQNAND (XOR,TRU) = LEQNAND (XOR,IF) = IMPNAND (XOR,FIX) = IMPNAND (XOR,LET) = IFNAND (XOR,NOR) = TRUNAND (IMP,LEQ) = XORNAND (IMP,OR) = DENYNAND (IMP,DENY) = ORNAND (IMP,FLIP) = FIXNAND (IMP,NIF) = IFNAND (IMP,NTRU) = TRUNAND (IMP,AND) = NANDNAND (IMP,NIMP) = TRUNAND (IMP,XOR) = IFNAND (IMP,IMP) = NIMPNAND (IMP,NAND) = FIXNAND (IMP,TRU) = NIMPNAND (IMP,IF) = XORNAND (IMP,FIX) = NANDNAND (IMP,LET) = DENYNAND (IMP,NOR) = ORNAND (NAND,LEQ) = ORNAND (NAND,OR) = LEQNAND (NAND,DENY) = LETNAND (NAND,FLIP) = FIXNAND (NAND,NIF) = IFNAND (NAND,NTRU) = TRUNAND (NAND,AND) = TRUNAND (NAND,NIMP) = IMPNAND (NAND,XOR) = LEQNAND (NAND,IMP) = FIXNAND (NAND,NAND) = ANDNAND (NAND,TRU) = ANDNAND (NAND,IF) = LETNAND (NAND,FIX) = IMPNAND (NAND,LET) = IFNAND (NAND,NOR) = ORNAND (TRU,LEQ) = XORNAND (TRU,OR) = NORNAND (TRU,DENY) = LETNAND (TRU,FLIP) = FIXNAND (TRU,NIF) = IFNAND (TRU,NTRU) = TRUNAND (TRU,AND) = NANDNAND (TRU,NIMP) = IMPNAND (TRU,XOR) = LEQNAND (TRU,IMP) = NIMPNAND (TRU,NAND) = ANDNAND (TRU,TRU) = NTRUNAND (TRU,IF) = NIFNAND (TRU,FIX) = FLIPNAND (TRU,LET) = DENYNAND (TRU,NOR) = ORNAND (IF,LEQ) = XORNAND (IF,OR) = FLIPNAND (IF,DENY) = LETNAND (IF,FLIP) = ORNAND (IF,NIF) = TRUNAND (IF,NTRU) = TRUNAND (IF,AND) = NANDNAND (IF,NIMP) = IMPNAND (IF,XOR) = IMPNAND (IF,IMP) = XORNAND (IF,NAND) = LETNAND (IF,TRU) = NIFNAND (IF,IF) = NIFNAND (IF,FIX) = FLIPNAND (IF,LET) = NANDNAND (IF,NOR) = ORNAND (FIX,LEQ) = NANDNAND (FIX,OR) = FLIPNAND (FIX,DENY) = IMPNAND (FIX,FLIP) = TRUNAND (FIX,NIF) = TRUNAND (FIX,NTRU) = TRUNAND (FIX,AND) = NANDNAND (FIX,NIMP) = IMPNAND (FIX,XOR) = IMPNAND (FIX,IMP) = NANDNAND (FIX,NAND) = IMPNAND (FIX,TRU) = FLIPNAND (FIX,IF) = FLIPNAND (FIX,FIX) = FLIPNAND (FIX,LET) = NANDNAND (FIX,NOR) = TRUNAND (LET,LEQ) = NANDNAND (LET,OR) = DENYNAND (LET,DENY) = TRUNAND (LET,FLIP) = IFNAND (LET,NIF) = IFNAND (LET,NTRU) = TRUNAND (LET,AND) = NANDNAND (LET,NIMP) = TRUNAND (LET,XOR) = IFNAND (LET,IMP) = DENYNAND (LET,NAND) = IFNAND (LET,TRU) = DENYNAND (LET,IF) = NANDNAND (LET,FIX) = NANDNAND (LET,LET) = DENYNAND (LET,NOR) = TRUNAND (NOR,LEQ) = ORNAND (NOR,OR) = TRUNAND (NOR,DENY) = ORNAND (NOR,FLIP) = ORNAND (NOR,NIF) = TRUNAND (NOR,NTRU) = TRUNAND (NOR,AND) = TRUNAND (NOR,NIMP) = TRUNAND (NOR,XOR) = TRUNAND (NOR,IMP) = ORNAND (NOR,NAND) = ORNAND (NOR,TRU) = ORNAND (NOR,IF) = ORNAND (NOR,FIX) = TRUNAND (NOR,LET) = TRUNAND (NOR,NOR) = ORTRU (LEQ,LEQ) = TRUTRU (LEQ,OR) = TRUTRU (LEQ,DENY) = TRUTRU (LEQ,FLIP) = TRUTRU (LEQ,NIF) = TRUTRU (LEQ,NTRU) = TRUTRU (LEQ,AND) = TRUTRU (LEQ,NIMP) = TRUTRU (LEQ,XOR) = TRUTRU (LEQ,IMP) = TRUTRU (LEQ,NAND) = TRUTRU (LEQ,TRU) = TRUTRU (LEQ,IF) = TRUTRU (LEQ,FIX) = TRUTRU (LEQ,LET) = TRUTRU (LEQ,NOR) = TRUTRU (OR,LEQ) = TRUTRU (OR,OR) = TRUTRU (OR,DENY) = TRUTRU (OR,FLIP) = TRUTRU (OR,NIF) = TRUTRU (OR,NTRU) = TRUTRU (OR,AND) = TRUTRU (OR,NIMP) = TRUTRU (OR,XOR) = TRUTRU (OR,IMP) = TRUTRU (OR,NAND) = TRUTRU (OR,TRU) = TRUTRU (OR,IF) = TRUTRU (OR,FIX) = TRUTRU (OR,LET) = TRUTRU (OR,NOR) = TRUTRU (DENY,LEQ) = TRUTRU (DENY,OR) = TRUTRU (DENY,DENY) = TRUTRU (DENY,FLIP) = TRUTRU (DENY,NIF) = TRUTRU (DENY,NTRU) = TRUTRU (DENY,AND) = TRUTRU (DENY,NIMP) = TRUTRU (DENY,XOR) = TRUTRU (DENY,IMP) = TRUTRU (DENY,NAND) = TRUTRU (DENY,TRU) = TRUTRU (DENY,IF) = TRUTRU (DENY,FIX) = TRUTRU (DENY,LET) = TRUTRU (DENY,NOR) = TRUTRU (FLIP,LEQ) = TRUTRU (FLIP,OR) = TRUTRU (FLIP,DENY) = TRUTRU (FLIP,FLIP) = TRUTRU (FLIP,NIF) = TRUTRU (FLIP,NTRU) = TRUTRU (FLIP,AND) = TRUTRU (FLIP,NIMP) = TRUTRU (FLIP,XOR) = TRUTRU (FLIP,IMP) = TRUTRU (FLIP,NAND) = TRUTRU (FLIP,TRU) = TRUTRU (FLIP,IF) = TRUTRU (FLIP,FIX) = TRUTRU (FLIP,LET) = TRUTRU (FLIP,NOR) = TRUTRU (NIF,LEQ) = TRUTRU (NIF,OR) = TRUTRU (NIF,DENY) = TRUTRU (NIF,FLIP) = TRUTRU (NIF,NIF) = TRUTRU (NIF,NTRU) = TRUTRU (NIF,AND) = TRUTRU (NIF,NIMP) = TRUTRU (NIF,XOR) = TRUTRU (NIF,IMP) = TRUTRU (NIF,NAND) = TRUTRU (NIF,TRU) = TRUTRU (NIF,IF) = TRUTRU (NIF,FIX) = TRUTRU (NIF,LET) = TRUTRU (NIF,NOR) = TRUTRU (NTRU,LEQ) = TRUTRU (NTRU,OR) = TRUTRU (NTRU,DENY) = TRUTRU (NTRU,FLIP) = TRUTRU (NTRU,NIF) = TRUTRU (NTRU,NTRU) = TRUTRU (NTRU,AND) = TRUTRU (NTRU,NIMP) = TRUTRU (NTRU,XOR) = TRUTRU (NTRU,IMP) = TRUTRU (NTRU,NAND) = TRUTRU (NTRU,TRU) = TRUTRU (NTRU,IF) = TRUTRU (NTRU,FIX) = TRUTRU (NTRU,LET) = TRUTRU (NTRU,NOR) = TRUTRU (AND,LEQ) = TRUTRU (AND,OR) = TRUTRU (AND,DENY) = TRUTRU (AND,FLIP) = TRUTRU (AND,NIF) = TRUTRU (AND,NTRU) = TRUTRU (AND,AND) = TRUTRU (AND,NIMP) = TRUTRU (AND,XOR) = TRUTRU (AND,IMP) = TRUTRU (AND,NAND) = TRUTRU (AND,TRU) = TRUTRU (AND,IF) = TRUTRU (AND,FIX) = TRUTRU (AND,LET) = TRUTRU (AND,NOR) = TRUTRU (NIMP,LEQ) = TRUTRU (NIMP,OR) = TRUTRU (NIMP,DENY) = TRUTRU (NIMP,FLIP) = TRUTRU (NIMP,NIF) = TRUTRU (NIMP,NTRU) = TRUTRU (NIMP,AND) = TRUTRU (NIMP,NIMP) = TRUTRU (NIMP,XOR) = TRUTRU (NIMP,IMP) = TRUTRU (NIMP,NAND) = TRUTRU (NIMP,TRU) = TRUTRU (NIMP,IF) = TRUTRU (NIMP,FIX) = TRUTRU (NIMP,LET) = TRUTRU (NIMP,NOR) = TRUTRU (XOR,LEQ) = TRUTRU (XOR,OR) = TRUTRU (XOR,DENY) = TRUTRU (XOR,FLIP) = TRUTRU (XOR,NIF) = TRUTRU (XOR,NTRU) = TRUTRU (XOR,AND) = TRUTRU (XOR,NIMP) = TRUTRU (XOR,XOR) = TRUTRU (XOR,IMP) = TRUTRU (XOR,NAND) = TRUTRU (XOR,TRU) = TRUTRU (XOR,IF) = TRUTRU (XOR,FIX) = TRUTRU (XOR,LET) = TRUTRU (XOR,NOR) = TRUTRU (IMP,LEQ) = TRUTRU (IMP,OR) = TRUTRU (IMP,DENY) = TRUTRU (IMP,FLIP) = TRUTRU (IMP,NIF) = TRUTRU (IMP,NTRU) = TRUTRU (IMP,AND) = TRUTRU (IMP,NIMP) = TRUTRU (IMP,XOR) = TRUTRU (IMP,IMP) = TRUTRU (IMP,NAND) = TRUTRU (IMP,TRU) = TRUTRU (IMP,IF) = TRUTRU (IMP,FIX) = TRUTRU (IMP,LET) = TRUTRU (IMP,NOR) = TRUTRU (NAND,LEQ) = TRUTRU (NAND,OR) = TRUTRU (NAND,DENY) = TRUTRU (NAND,FLIP) = TRUTRU (NAND,NIF) = TRUTRU (NAND,NTRU) = TRUTRU (NAND,AND) = TRUTRU (NAND,NIMP) = TRUTRU (NAND,XOR) = TRUTRU (NAND,IMP) = TRUTRU (NAND,NAND) = TRUTRU (NAND,TRU) = TRUTRU (NAND,IF) = TRUTRU (NAND,FIX) = TRUTRU (NAND,LET) = TRUTRU (NAND,NOR) = TRUTRU (TRU,LEQ) = TRUTRU (TRU,OR) = TRUTRU (TRU,DENY) = TRUTRU (TRU,FLIP) = TRUTRU (TRU,NIF) = TRUTRU (TRU,NTRU) = TRUTRU (TRU,AND) = TRUTRU (TRU,NIMP) = TRUTRU (TRU,XOR) = TRUTRU (TRU,IMP) = TRUTRU (TRU,NAND) = TRUTRU (TRU,TRU) = TRUTRU (TRU,IF) = TRUTRU (TRU,FIX) = TRUTRU (TRU,LET) = TRUTRU (TRU,NOR) = TRUTRU (IF,LEQ) = TRUTRU (IF,OR) = TRUTRU (IF,DENY) = TRUTRU (IF,FLIP) = TRUTRU (IF,NIF) = TRUTRU (IF,NTRU) = TRUTRU (IF,AND) = TRUTRU (IF,NIMP) = TRUTRU (IF,XOR) = TRUTRU (IF,IMP) = TRUTRU (IF,NAND) = TRUTRU (IF,TRU) = TRUTRU (IF,IF) = TRUTRU (IF,FIX) = TRUTRU (IF,LET) = TRUTRU (IF,NOR) = TRUTRU (FIX,LEQ) = TRUTRU (FIX,OR) = TRUTRU (FIX,DENY) = TRUTRU (FIX,FLIP) = TRUTRU (FIX,NIF) = TRUTRU (FIX,NTRU) = TRUTRU (FIX,AND) = TRUTRU (FIX,NIMP) = TRUTRU (FIX,XOR) = TRUTRU (FIX,IMP) = TRUTRU (FIX,NAND) = TRUTRU (FIX,TRU) = TRUTRU (FIX,IF) = TRUTRU (FIX,FIX) = TRUTRU (FIX,LET) = TRUTRU (FIX,NOR) = TRUTRU (LET,LEQ) = TRUTRU (LET,OR) = TRUTRU (LET,DENY) = TRUTRU (LET,FLIP) = TRUTRU (LET,NIF) = TRUTRU (LET,NTRU) = TRUTRU (LET,AND) = TRUTRU (LET,NIMP) = TRUTRU (LET,XOR) = TRUTRU (LET,IMP) = TRUTRU (LET,NAND) = TRUTRU (LET,TRU) = TRUTRU (LET,IF) = TRUTRU (LET,FIX) = TRUTRU (LET,LET) = TRUTRU (LET,NOR) = TRUTRU (NOR,LEQ) = TRUTRU (NOR,OR) = TRUTRU (NOR,DENY) = TRUTRU (NOR,FLIP) = TRUTRU (NOR,NIF) = TRUTRU (NOR,NTRU) = TRUTRU (NOR,AND) = TRUTRU (NOR,NIMP) = TRUTRU (NOR,XOR) = TRUTRU (NOR,IMP) = TRUTRU (NOR,NAND) = TRUTRU (NOR,TRU) = TRUTRU (NOR,IF) = TRUTRU (NOR,FIX) = TRUTRU (NOR,LET) = TRUTRU (NOR,NOR) = TRUIF (LEQ,LEQ) = TRUIF (LEQ,OR) = LEQIF (LEQ,DENY) = IMPIF (LEQ,FLIP) = IFIF (LEQ,NIF) = IFIF (LEQ,NTRU) = TRUIF (LEQ,AND) = TRUIF (LEQ,NIMP) = IMPIF (LEQ,XOR) = LEQIF (LEQ,IMP) = IFIF (LEQ,NAND) = LEQIF (LEQ,TRU) = LEQIF (LEQ,IF) = IMPIF (LEQ,FIX) = IMPIF (LEQ,LET) = IFIF (LEQ,NOR) = TRUIF (OR,LEQ) = ORIF (OR,OR) = TRUIF (OR,DENY) = ORIF (OR,FLIP) = ORIF (OR,NIF) = TRUIF (OR,NTRU) = TRUIF (OR,AND) = TRUIF (OR,NIMP) = TRUIF (OR,XOR) = TRUIF (OR,IMP) = ORIF (OR,NAND) = ORIF (OR,TRU) = ORIF (OR,IF) = ORIF (OR,FIX) = TRUIF (OR,LET) = TRUIF (OR,NOR) = ORIF (DENY,LEQ) = NANDIF (DENY,OR) = DENYIF (DENY,DENY) = TRUIF (DENY,FLIP) = IFIF (DENY,NIF) = IFIF (DENY,NTRU) = TRUIF (DENY,AND) = NANDIF (DENY,NIMP) = TRUIF (DENY,XOR) = IFIF (DENY,IMP) = DENYIF (DENY,NAND) = IFIF (DENY,TRU) = DENYIF (DENY,IF) = NANDIF (DENY,FIX) = NANDIF (DENY,LET) = DENYIF (DENY,NOR) = TRUIF (FLIP,LEQ) = NANDIF (FLIP,OR) = FLIPIF (FLIP,DENY) = IMPIF (FLIP,FLIP) = TRUIF (FLIP,NIF) = TRUIF (FLIP,NTRU) = TRUIF (FLIP,AND) = NANDIF (FLIP,NIMP) = IMPIF (FLIP,XOR) = IMPIF (FLIP,IMP) = NANDIF (FLIP,NAND) = IMPIF (FLIP,TRU) = FLIPIF (FLIP,IF) = FLIPIF (FLIP,FIX) = FLIPIF (FLIP,LET) = NANDIF (FLIP,NOR) = TRUIF (NIF,LEQ) = XORIF (NIF,OR) = FLIPIF (NIF,DENY) = LETIF (NIF,FLIP) = ORIF (NIF,NIF) = TRUIF (NIF,NTRU) = TRUIF (NIF,AND) = NANDIF (NIF,NIMP) = IMPIF (NIF,XOR) = IMPIF (NIF,IMP) = XORIF (NIF,NAND) = LETIF (NIF,TRU) = NIFIF (NIF,IF) = NIFIF (NIF,FIX) = FLIPIF (NIF,LET) = NANDIF (NIF,NOR) = ORIF (NTRU,LEQ) = XORIF (NTRU,OR) = NORIF (NTRU,DENY) = LETIF (NTRU,FLIP) = FIXIF (NTRU,NIF) = IFIF (NTRU,NTRU) = TRUIF (NTRU,AND) = NANDIF (NTRU,NIMP) = IMPIF (NTRU,XOR) = LEQIF (NTRU,IMP) = NIMPIF (NTRU,NAND) = ANDIF (NTRU,TRU) = NTRUIF (NTRU,IF) = NIFIF (NTRU,FIX) = FLIPIF (NTRU,LET) = DENYIF (NTRU,NOR) = ORIF (AND,LEQ) = ORIF (AND,OR) = LEQIF (AND,DENY) = LETIF (AND,FLIP) = FIXIF (AND,NIF) = IFIF (AND,NTRU) = TRUIF (AND,AND) = TRUIF (AND,NIMP) = IMPIF (AND,XOR) = LEQIF (AND,IMP) = FIXIF (AND,NAND) = ANDIF (AND,TRU) = ANDIF (AND,IF) = LETIF (AND,FIX) = IMPIF (AND,LET) = IFIF (AND,NOR) = ORIF (NIMP,LEQ) = XORIF (NIMP,OR) = DENYIF (NIMP,DENY) = ORIF (NIMP,FLIP) = FIXIF (NIMP,NIF) = IFIF (NIMP,NTRU) = TRUIF (NIMP,AND) = NANDIF (NIMP,NIMP) = TRUIF (NIMP,XOR) = IFIF (NIMP,IMP) = NIMPIF (NIMP,NAND) = FIXIF (NIMP,TRU) = NIMPIF (NIMP,IF) = XORIF (NIMP,FIX) = NANDIF (NIMP,LET) = DENYIF (NIMP,NOR) = ORIF (XOR,LEQ) = XORIF (XOR,OR) = NANDIF (XOR,DENY) = ORIF (XOR,FLIP) = ORIF (XOR,NIF) = TRUIF (XOR,NTRU) = TRUIF (XOR,AND) = NANDIF (XOR,NIMP) = TRUIF (XOR,XOR) = TRUIF (XOR,IMP) = XORIF (XOR,NAND) = ORIF (XOR,TRU) = XORIF (XOR,IF) = XORIF (XOR,FIX) = NANDIF (XOR,LET) = NANDIF (XOR,NOR) = ORIF (IMP,LEQ) = TRUIF (IMP,OR) = IMPIF (IMP,DENY) = IMPIF (IMP,FLIP) = TRUIF (IMP,NIF) = TRUIF (IMP,NTRU) = TRUIF (IMP,AND) = TRUIF (IMP,NIMP) = IMPIF (IMP,XOR) = IMPIF (IMP,IMP) = TRUIF (IMP,NAND) = IMPIF (IMP,TRU) = IMPIF (IMP,IF) = IMPIF (IMP,FIX) = IMPIF (IMP,LET) = TRUIF (IMP,NOR) = TRUIF (NAND,LEQ) = NANDIF (NAND,OR) = NANDIF (NAND,DENY) = TRUIF (NAND,FLIP) = TRUIF (NAND,NIF) = TRUIF (NAND,NTRU) = TRUIF (NAND,AND) = NANDIF (NAND,NIMP) = TRUIF (NAND,XOR) = TRUIF (NAND,IMP) = NANDIF (NAND,NAND) = TRUIF (NAND,TRU) = NANDIF (NAND,IF) = NANDIF (NAND,FIX) = NANDIF (NAND,LET) = NANDIF (NAND,NOR) = TRUIF (TRU,LEQ) = TRUIF (TRU,OR) = TRUIF (TRU,DENY) = TRUIF (TRU,FLIP) = TRUIF (TRU,NIF) = TRUIF (TRU,NTRU) = TRUIF (TRU,AND) = TRUIF (TRU,NIMP) = TRUIF (TRU,XOR) = TRUIF (TRU,IMP) = TRUIF (TRU,NAND) = TRUIF (TRU,TRU) = TRUIF (TRU,IF) = TRUIF (TRU,FIX) = TRUIF (TRU,LET) = TRUIF (TRU,NOR) = TRUIF (IF,LEQ) = TRUIF (IF,OR) = IFIF (IF,DENY) = TRUIF (IF,FLIP) = IFIF (IF,NIF) = IFIF (IF,NTRU) = TRUIF (IF,AND) = TRUIF (IF,NIMP) = TRUIF (IF,XOR) = IFIF (IF,IMP) = IFIF (IF,NAND) = IFIF (IF,TRU) = IFIF (IF,IF) = TRUIF (IF,FIX) = TRUIF (IF,LET) = IFIF (IF,NOR) = TRUIF (FIX,LEQ) = ORIF (FIX,OR) = IFIF (FIX,DENY) = ORIF (FIX,FLIP) = FIXIF (FIX,NIF) = IFIF (FIX,NTRU) = TRUIF (FIX,AND) = TRUIF (FIX,NIMP) = TRUIF (FIX,XOR) = IFIF (FIX,IMP) = FIXIF (FIX,NAND) = FIXIF (FIX,TRU) = FIXIF (FIX,IF) = ORIF (FIX,FIX) = TRUIF (FIX,LET) = IFIF (FIX,NOR) = ORIF (LET,LEQ) = ORIF (LET,OR) = IMPIF (LET,DENY) = LETIF (LET,FLIP) = ORIF (LET,NIF) = TRUIF (LET,NTRU) = TRUIF (LET,AND) = TRUIF (LET,NIMP) = IMPIF (LET,XOR) = IMPIF (LET,IMP) = ORIF (LET,NAND) = LETIF (LET,TRU) = LETIF (LET,IF) = LETIF (LET,FIX) = IMPIF (LET,LET) = TRUIF (LET,NOR) = ORIF (NOR,LEQ) = NANDIF (NOR,OR) = NORIF (NOR,DENY) = IMPIF (NOR,FLIP) = IFIF (NOR,NIF) = IFIF (NOR,NTRU) = TRUIF (NOR,AND) = NANDIF (NOR,NIMP) = IMPIF (NOR,XOR) = LEQIF (NOR,IMP) = DENYIF (NOR,NAND) = LEQIF (NOR,TRU) = NORIF (NOR,IF) = FLIPIF (NOR,FIX) = FLIPIF (NOR,LET) = DENYIF (NOR,NOR) = TRUFIX (LEQ,LEQ) = LEQFIX (LEQ,OR) = LEQFIX (LEQ,DENY) = LEQFIX (LEQ,FLIP) = LEQFIX (LEQ,NIF) = LEQFIX (LEQ,NTRU) = LEQFIX (LEQ,AND) = LEQFIX (LEQ,NIMP) = LEQFIX (LEQ,XOR) = LEQFIX (LEQ,IMP) = LEQFIX (LEQ,NAND) = LEQFIX (LEQ,TRU) = LEQFIX (LEQ,IF) = LEQFIX (LEQ,FIX) = LEQFIX (LEQ,LET) = LEQFIX (LEQ,NOR) = LEQFIX (OR,LEQ) = ORFIX (OR,OR) = ORFIX (OR,DENY) = ORFIX (OR,FLIP) = ORFIX (OR,NIF) = ORFIX (OR,NTRU) = ORFIX (OR,AND) = ORFIX (OR,NIMP) = ORFIX (OR,XOR) = ORFIX (OR,IMP) = ORFIX (OR,NAND) = ORFIX (OR,TRU) = ORFIX (OR,IF) = ORFIX (OR,FIX) = ORFIX (OR,LET) = ORFIX (OR,NOR) = ORFIX (DENY,LEQ) = DENYFIX (DENY,OR) = DENYFIX (DENY,DENY) = DENYFIX (DENY,FLIP) = DENYFIX (DENY,NIF) = DENYFIX (DENY,NTRU) = DENYFIX (DENY,AND) = DENYFIX (DENY,NIMP) = DENYFIX (DENY,XOR) = DENYFIX (DENY,IMP) = DENYFIX (DENY,NAND) = DENYFIX (DENY,TRU) = DENYFIX (DENY,IF) = DENYFIX (DENY,FIX) = DENYFIX (DENY,LET) = DENYFIX (DENY,NOR) = DENYFIX (FLIP,LEQ) = FLIPFIX (FLIP,OR) = FLIPFIX (FLIP,DENY) = FLIPFIX (FLIP,FLIP) = FLIPFIX (FLIP,NIF) = FLIPFIX (FLIP,NTRU) = FLIPFIX (FLIP,AND) = FLIPFIX (FLIP,NIMP) = FLIPFIX (FLIP,XOR) = FLIPFIX (FLIP,IMP) = FLIPFIX (FLIP,NAND) = FLIPFIX (FLIP,TRU) = FLIPFIX (FLIP,IF) = FLIPFIX (FLIP,FIX) = FLIPFIX (FLIP,LET) = FLIPFIX (FLIP,NOR) = FLIPFIX (NIF,LEQ) = NIFFIX (NIF,OR) = NIFFIX (NIF,DENY) = NIFFIX (NIF,FLIP) = NIFFIX (NIF,NIF) = NIFFIX (NIF,NTRU) = NIFFIX (NIF,AND) = NIFFIX (NIF,NIMP) = NIFFIX (NIF,XOR) = NIFFIX (NIF,IMP) = NIFFIX (NIF,NAND) = NIFFIX (NIF,TRU) = NIFFIX (NIF,IF) = NIFFIX (NIF,FIX) = NIFFIX (NIF,LET) = NIFFIX (NIF,NOR) = NIFFIX (NTRU,LEQ) = NTRUFIX (NTRU,OR) = NTRUFIX (NTRU,DENY) = NTRUFIX (NTRU,FLIP) = NTRUFIX (NTRU,NIF) = NTRUFIX (NTRU,NTRU) = NTRUFIX (NTRU,AND) = NTRUFIX (NTRU,NIMP) = NTRUFIX (NTRU,XOR) = NTRUFIX (NTRU,IMP) = NTRUFIX (NTRU,NAND) = NTRUFIX (NTRU,TRU) = NTRUFIX (NTRU,IF) = NTRUFIX (NTRU,FIX) = NTRUFIX (NTRU,LET) = NTRUFIX (NTRU,NOR) = NTRUFIX (AND,LEQ) = ANDFIX (AND,OR) = ANDFIX (AND,DENY) = ANDFIX (AND,FLIP) = ANDFIX (AND,NIF) = ANDFIX (AND,NTRU) = ANDFIX (AND,AND) = ANDFIX (AND,NIMP) = ANDFIX (AND,XOR) = ANDFIX (AND,IMP) = ANDFIX (AND,NAND) = ANDFIX (AND,TRU) = ANDFIX (AND,IF) = ANDFIX (AND,FIX) = ANDFIX (AND,LET) = ANDFIX (AND,NOR) = ANDFIX (NIMP,LEQ) = NIMPFIX (NIMP,OR) = NIMPFIX (NIMP,DENY) = NIMPFIX (NIMP,FLIP) = NIMPFIX (NIMP,NIF) = NIMPFIX (NIMP,NTRU) = NIMPFIX (NIMP,AND) = NIMPFIX (NIMP,NIMP) = NIMPFIX (NIMP,XOR) = NIMPFIX (NIMP,IMP) = NIMPFIX (NIMP,NAND) = NIMPFIX (NIMP,TRU) = NIMPFIX (NIMP,IF) = NIMPFIX (NIMP,FIX) = NIMPFIX (NIMP,LET) = NIMPFIX (NIMP,NOR) = NIMPFIX (XOR,LEQ) = XORFIX (XOR,OR) = XORFIX (XOR,DENY) = XORFIX (XOR,FLIP) = XORFIX (XOR,NIF) = XORFIX (XOR,NTRU) = XORFIX (XOR,AND) = XORFIX (XOR,NIMP) = XORFIX (XOR,XOR) = XORFIX (XOR,IMP) = XORFIX (XOR,NAND) = XORFIX (XOR,TRU) = XORFIX (XOR,IF) = XORFIX (XOR,FIX) = XORFIX (XOR,LET) = XORFIX (XOR,NOR) = XORFIX (IMP,LEQ) = IMPFIX (IMP,OR) = IMPFIX (IMP,DENY) = IMPFIX (IMP,FLIP) = IMPFIX (IMP,NIF) = IMPFIX (IMP,NTRU) = IMPFIX (IMP,AND) = IMPFIX (IMP,NIMP) = IMPFIX (IMP,XOR) = IMPFIX (IMP,IMP) = IMPFIX (IMP,NAND) = IMPFIX (IMP,TRU) = IMPFIX (IMP,IF) = IMPFIX (IMP,FIX) = IMPFIX (IMP,LET) = IMPFIX (IMP,NOR) = IMPFIX (NAND,LEQ) = NANDFIX (NAND,OR) = NANDFIX (NAND,DENY) = NANDFIX (NAND,FLIP) = NANDFIX (NAND,NIF) = NANDFIX (NAND,NTRU) = NANDFIX (NAND,AND) = NANDFIX (NAND,NIMP) = NANDFIX (NAND,XOR) = NANDFIX (NAND,IMP) = NANDFIX (NAND,NAND) = NANDFIX (NAND,TRU) = NANDFIX (NAND,IF) = NANDFIX (NAND,FIX) = NANDFIX (NAND,LET) = NANDFIX (NAND,NOR) = NANDFIX (TRU,LEQ) = TRUFIX (TRU,OR) = TRUFIX (TRU,DENY) = TRUFIX (TRU,FLIP) = TRUFIX (TRU,NIF) = TRUFIX (TRU,NTRU) = TRUFIX (TRU,AND) = TRUFIX (TRU,NIMP) = TRUFIX (TRU,XOR) = TRUFIX (TRU,IMP) = TRUFIX (TRU,NAND) = TRUFIX (TRU,TRU) = TRUFIX (TRU,IF) = TRUFIX (TRU,FIX) = TRUFIX (TRU,LET) = TRUFIX (TRU,NOR) = TRUFIX (IF,LEQ) = IFFIX (IF,OR) = IFFIX (IF,DENY) = IFFIX (IF,FLIP) = IFFIX (IF,NIF) = IFFIX (IF,NTRU) = IFFIX (IF,AND) = IFFIX (IF,NIMP) = IFFIX (IF,XOR) = IFFIX (IF,IMP) = IFFIX (IF,NAND) = IFFIX (IF,TRU) = IFFIX (IF,IF) = IFFIX (IF,FIX) = IFFIX (IF,LET) = IFFIX (IF,NOR) = IFFIX (FIX,LEQ) = FIXFIX (FIX,OR) = FIXFIX (FIX,DENY) = FIXFIX (FIX,FLIP) = FIXFIX (FIX,NIF) = FIXFIX (FIX,NTRU) = FIXFIX (FIX,AND) = FIXFIX (FIX,NIMP) = FIXFIX (FIX,XOR) = FIXFIX (FIX,IMP) = FIXFIX (FIX,NAND) = FIXFIX (FIX,TRU) = FIXFIX (FIX,IF) = FIXFIX (FIX,FIX) = FIXFIX (FIX,LET) = FIXFIX (FIX,NOR) = FIXFIX (LET,LEQ) = LETFIX (LET,OR) = LETFIX (LET,DENY) = LETFIX (LET,FLIP) = LETFIX (LET,NIF) = LETFIX (LET,NTRU) = LETFIX (LET,AND) = LETFIX (LET,NIMP) = LETFIX (LET,XOR) = LETFIX (LET,IMP) = LETFIX (LET,NAND) = LETFIX (LET,TRU) = LETFIX (LET,IF) = LETFIX (LET,FIX) = LETFIX (LET,LET) = LETFIX (LET,NOR) = LETFIX (NOR,LEQ) = NORFIX (NOR,OR) = NORFIX (NOR,DENY) = NORFIX (NOR,FLIP) = NORFIX (NOR,NIF) = NORFIX (NOR,NTRU) = NORFIX (NOR,AND) = NORFIX (NOR,NIMP) = NORFIX (NOR,XOR) = NORFIX (NOR,IMP) = NORFIX (NOR,NAND) = NORFIX (NOR,TRU) = NORFIX (NOR,IF) = NORFIX (NOR,FIX) = NORFIX (NOR,LET) = NORFIX (NOR,NOR) = NORLET (LEQ,LEQ) = LEQLET (LEQ,OR) = ORLET (LEQ,DENY) = DENYLET (LEQ,FLIP) = FLIPLET (LEQ,NIF) = NIFLET (LEQ,NTRU) = NTRULET (LEQ,AND) = ANDLET (LEQ,NIMP) = NIMPLET (LEQ,XOR) = XORLET (LEQ,IMP) = IMPLET (LEQ,NAND) = NANDLET (LEQ,TRU) = TRULET (LEQ,IF) = IFLET (LEQ,FIX) = FIXLET (LEQ,LET) = LETLET (LEQ,NOR) = NORLET (OR,LEQ) = LEQLET (OR,OR) = ORLET (OR,DENY) = DENYLET (OR,FLIP) = FLIPLET (OR,NIF) = NIFLET (OR,NTRU) = NTRULET (OR,AND) = ANDLET (OR,NIMP) = NIMPLET (OR,XOR) = XORLET (OR,IMP) = IMPLET (OR,NAND) = NANDLET (OR,TRU) = TRULET (OR,IF) = IFLET (OR,FIX) = FIXLET (OR,LET) = LETLET (OR,NOR) = NORLET (DENY,LEQ) = LEQLET (DENY,OR) = ORLET (DENY,DENY) = DENYLET (DENY,FLIP) = FLIPLET (DENY,NIF) = NIFLET (DENY,NTRU) = NTRULET (DENY,AND) = ANDLET (DENY,NIMP) = NIMPLET (DENY,XOR) = XORLET (DENY,IMP) = IMPLET (DENY,NAND) = NANDLET (DENY,TRU) = TRULET (DENY,IF) = IFLET (DENY,FIX) = FIXLET (DENY,LET) = LETLET (DENY,NOR) = NORLET (FLIP,LEQ) = LEQLET (FLIP,OR) = ORLET (FLIP,DENY) = DENYLET (FLIP,FLIP) = FLIPLET (FLIP,NIF) = NIFLET (FLIP,NTRU) = NTRULET (FLIP,AND) = ANDLET (FLIP,NIMP) = NIMPLET (FLIP,XOR) = XORLET (FLIP,IMP) = IMPLET (FLIP,NAND) = NANDLET (FLIP,TRU) = TRULET (FLIP,IF) = IFLET (FLIP,FIX) = FIXLET (FLIP,LET) = LETLET (FLIP,NOR) = NORLET (NIF,LEQ) = LEQLET (NIF,OR) = ORLET (NIF,DENY) = DENYLET (NIF,FLIP) = FLIPLET (NIF,NIF) = NIFLET (NIF,NTRU) = NTRULET (NIF,AND) = ANDLET (NIF,NIMP) = NIMPLET (NIF,XOR) = XORLET (NIF,IMP) = IMPLET (NIF,NAND) = NANDLET (NIF,TRU) = TRULET (NIF,IF) = IFLET (NIF,FIX) = FIXLET (NIF,LET) = LETLET (NIF,NOR) = NORLET (NTRU,LEQ) = LEQLET (NTRU,OR) = ORLET (NTRU,DENY) = DENYLET (NTRU,FLIP) = FLIPLET (NTRU,NIF) = NIFLET (NTRU,NTRU) = NTRULET (NTRU,AND) = ANDLET (NTRU,NIMP) = NIMPLET (NTRU,XOR) = XORLET (NTRU,IMP) = IMPLET (NTRU,NAND) = NANDLET (NTRU,TRU) = TRULET (NTRU,IF) = IFLET (NTRU,FIX) = FIXLET (NTRU,LET) = LETLET (NTRU,NOR) = NORLET (AND,LEQ) = LEQLET (AND,OR) = ORLET (AND,DENY) = DENYLET (AND,FLIP) = FLIPLET (AND,NIF) = NIFLET (AND,NTRU) = NTRULET (AND,AND) = ANDLET (AND,NIMP) = NIMPLET (AND,XOR) = XORLET (AND,IMP) = IMPLET (AND,NAND) = NANDLET (AND,TRU) = TRULET (AND,IF) = IFLET (AND,FIX) = FIXLET (AND,LET) = LETLET (AND,NOR) = NORLET (NIMP,LEQ) = LEQLET (NIMP,OR) = ORLET (NIMP,DENY) = DENYLET (NIMP,FLIP) = FLIPLET (NIMP,NIF) = NIFLET (NIMP,NTRU) = NTRULET (NIMP,AND) = ANDLET (NIMP,NIMP) = NIMPLET (NIMP,XOR) = XORLET (NIMP,IMP) = IMPLET (NIMP,NAND) = NANDLET (NIMP,TRU) = TRULET (NIMP,IF) = IFLET (NIMP,FIX) = FIXLET (NIMP,LET) = LETLET (NIMP,NOR) = NORLET (XOR,LEQ) = LEQLET (XOR,OR) = ORLET (XOR,DENY) = DENYLET (XOR,FLIP) = FLIPLET (XOR,NIF) = NIFLET (XOR,NTRU) = NTRULET (XOR,AND) = ANDLET (XOR,NIMP) = NIMPLET (XOR,XOR) = XORLET (XOR,IMP) = IMPLET (XOR,NAND) = NANDLET (XOR,TRU) = TRULET (XOR,IF) = IFLET (XOR,FIX) = FIXLET (XOR,LET) = LETLET (XOR,NOR) = NORLET (IMP,LEQ) = LEQLET (IMP,OR) = ORLET (IMP,DENY) = DENYLET (IMP,FLIP) = FLIPLET (IMP,NIF) = NIFLET (IMP,NTRU) = NTRULET (IMP,AND) = ANDLET (IMP,NIMP) = NIMPLET (IMP,XOR) = XORLET (IMP,IMP) = IMPLET (IMP,NAND) = NANDLET (IMP,TRU) = TRULET (IMP,IF) = IFLET (IMP,FIX) = FIXLET (IMP,LET) = LETLET (IMP,NOR) = NORLET (NAND,LEQ) = LEQLET (NAND,OR) = ORLET (NAND,DENY) = DENYLET (NAND,FLIP) = FLIPLET (NAND,NIF) = NIFLET (NAND,NTRU) = NTRULET (NAND,AND) = ANDLET (NAND,NIMP) = NIMPLET (NAND,XOR) = XORLET (NAND,IMP) = IMPLET (NAND,NAND) = NANDLET (NAND,TRU) = TRULET (NAND,IF) = IFLET (NAND,FIX) = FIXLET (NAND,LET) = LETLET (NAND,NOR) = NORLET (TRU,LEQ) = LEQLET (TRU,OR) = ORLET (TRU,DENY) = DENYLET (TRU,FLIP) = FLIPLET (TRU,NIF) = NIFLET (TRU,NTRU) = NTRULET (TRU,AND) = ANDLET (TRU,NIMP) = NIMPLET (TRU,XOR) = XORLET (TRU,IMP) = IMPLET (TRU,NAND) = NANDLET (TRU,TRU) = TRULET (TRU,IF) = IFLET (TRU,FIX) = FIXLET (TRU,LET) = LETLET (TRU,NOR) = NORLET (IF,LEQ) = LEQLET (IF,OR) = ORLET (IF,DENY) = DENYLET (IF,FLIP) = FLIPLET (IF,NIF) = NIFLET (IF,NTRU) = NTRULET (IF,AND) = ANDLET (IF,NIMP) = NIMPLET (IF,XOR) = XORLET (IF,IMP) = IMPLET (IF,NAND) = NANDLET (IF,TRU) = TRULET (IF,IF) = IFLET (IF,FIX) = FIXLET (IF,LET) = LETLET (IF,NOR) = NORLET (FIX,LEQ) = LEQLET (FIX,OR) = ORLET (FIX,DENY) = DENYLET (FIX,FLIP) = FLIPLET (FIX,NIF) = NIFLET (FIX,NTRU) = NTRULET (FIX,AND) = ANDLET (FIX,NIMP) = NIMPLET (FIX,XOR) = XORLET (FIX,IMP) = IMPLET (FIX,NAND) = NANDLET (FIX,TRU) = TRULET (FIX,IF) = IFLET (FIX,FIX) = FIXLET (FIX,LET) = LETLET (FIX,NOR) = NORLET (LET,LEQ) = LEQLET (LET,OR) = ORLET (LET,DENY) = DENYLET (LET,FLIP) = FLIPLET (LET,NIF) = NIFLET (LET,NTRU) = NTRULET (LET,AND) = ANDLET (LET,NIMP) = NIMPLET (LET,XOR) = XORLET (LET,IMP) = IMPLET (LET,NAND) = NANDLET (LET,TRU) = TRULET (LET,IF) = IFLET (LET,FIX) = FIXLET (LET,LET) = LETLET (LET,NOR) = NORLET (NOR,LEQ) = LEQLET (NOR,OR) = ORLET (NOR,DENY) = DENYLET (NOR,FLIP) = FLIPLET (NOR,NIF) = NIFLET (NOR,NTRU) = NTRULET (NOR,AND) = ANDLET (NOR,NIMP) = NIMPLET (NOR,XOR) = XORLET (NOR,IMP) = IMPLET (NOR,NAND) = NANDLET (NOR,TRU) = TRULET (NOR,IF) = IFLET (NOR,FIX) = FIXLET (NOR,LET) = LETLET (NOR,NOR) = NORNOR (LEQ,LEQ) = XORNOR (LEQ,OR) = NTRUNOR (LEQ,DENY) = NIFNOR (LEQ,FLIP) = NIMPNOR (LEQ,NIF) = NIMPNOR (LEQ,NTRU) = XORNOR (LEQ,AND) = XORNOR (LEQ,NIMP) = NIFNOR (LEQ,XOR) = NTRUNOR (LEQ,IMP) = NIMPNOR (LEQ,NAND) = NTRUNOR (LEQ,TRU) = NTRUNOR (LEQ,IF) = NIFNOR (LEQ,FIX) = NIFNOR (LEQ,LET) = NIMPNOR (LEQ,NOR) = XORNOR (OR,LEQ) = NTRUNOR (OR,OR) = NORNOR (OR,DENY) = NTRUNOR (OR,FLIP) = NTRUNOR (OR,NIF) = NORNOR (OR,NTRU) = NORNOR (OR,AND) = NORNOR (OR,NIMP) = NORNOR (OR,XOR) = NORNOR (OR,IMP) = NTRUNOR (OR,NAND) = NTRUNOR (OR,TRU) = NTRUNOR (OR,IF) = NTRUNOR (OR,FIX) = NORNOR (OR,LET) = NORNOR (OR,NOR) = NTRUNOR (DENY,LEQ) = NIFNOR (DENY,OR) = NTRUNOR (DENY,DENY) = LETNOR (DENY,FLIP) = ANDNOR (DENY,NIF) = ANDNOR (DENY,NTRU) = LETNOR (DENY,AND) = NIFNOR (DENY,NIMP) = LETNOR (DENY,XOR) = ANDNOR (DENY,IMP) = NTRUNOR (DENY,NAND) = ANDNOR (DENY,TRU) = NTRUNOR (DENY,IF) = NIFNOR (DENY,FIX) = NIFNOR (DENY,LET) = NTRUNOR (DENY,NOR) = LETNOR (FLIP,LEQ) = NIMPNOR (FLIP,OR) = NTRUNOR (FLIP,DENY) = ANDNOR (FLIP,FLIP) = FIXNOR (FLIP,NIF) = FIXNOR (FLIP,NTRU) = FIXNOR (FLIP,AND) = NIMPNOR (FLIP,NIMP) = ANDNOR (FLIP,XOR) = ANDNOR (FLIP,IMP) = NIMPNOR (FLIP,NAND) = ANDNOR (FLIP,TRU) = NTRUNOR (FLIP,IF) = NTRUNOR (FLIP,FIX) = NTRUNOR (FLIP,LET) = NIMPNOR (FLIP,NOR) = FIXNOR (NIF,LEQ) = NIMPNOR (NIF,OR) = NORNOR (NIF,DENY) = ANDNOR (NIF,FLIP) = FIXNOR (NIF,NIF) = IFNOR (NIF,NTRU) = IFNOR (NIF,AND) = DENYNOR (NIF,NIMP) = LEQNOR (NIF,XOR) = LEQNOR (NIF,IMP) = NIMPNOR (NIF,NAND) = ANDNOR (NIF,TRU) = NTRUNOR (NIF,IF) = NTRUNOR (NIF,FIX) = NORNOR (NIF,LET) = DENYNOR (NIF,NOR) = FIXNOR (NTRU,LEQ) = XORNOR (NTRU,OR) = NORNOR (NTRU,DENY) = LETNOR (NTRU,FLIP) = FIXNOR (NTRU,NIF) = IFNOR (NTRU,NTRU) = TRUNOR (NTRU,AND) = NANDNOR (NTRU,NIMP) = IMPNOR (NTRU,XOR) = LEQNOR (NTRU,IMP) = NIMPNOR (NTRU,NAND) = ANDNOR (NTRU,TRU) = NTRUNOR (NTRU,IF) = NIFNOR (NTRU,FIX) = FLIPNOR (NTRU,LET) = DENYNOR (NTRU,NOR) = ORNOR (AND,LEQ) = XORNOR (AND,OR) = NORNOR (AND,DENY) = NIFNOR (AND,FLIP) = NIMPNOR (AND,NIF) = DENYNOR (AND,NTRU) = NANDNOR (AND,AND) = NANDNOR (AND,NIMP) = FLIPNOR (AND,XOR) = NORNOR (AND,IMP) = NIMPNOR (AND,NAND) = NTRUNOR (AND,TRU) = NTRUNOR (AND,IF) = NIFNOR (AND,FIX) = FLIPNOR (AND,LET) = DENYNOR (AND,NOR) = XORNOR (NIMP,LEQ) = NIFNOR (NIMP,OR) = NORNOR (NIMP,DENY) = LETNOR (NIMP,FLIP) = ANDNOR (NIMP,NIF) = LEQNOR (NIMP,NTRU) = IMPNOR (NIMP,AND) = FLIPNOR (NIMP,NIMP) = IMPNOR (NIMP,XOR) = LEQNOR (NIMP,IMP) = NTRUNOR (NIMP,NAND) = ANDNOR (NIMP,TRU) = NTRUNOR (NIMP,IF) = NIFNOR (NIMP,FIX) = FLIPNOR (NIMP,LET) = NORNOR (NIMP,NOR) = LETNOR (XOR,LEQ) = NTRUNOR (XOR,OR) = NORNOR (XOR,DENY) = ANDNOR (XOR,FLIP) = ANDNOR (XOR,NIF) = LEQNOR (XOR,NTRU) = LEQNOR (XOR,AND) = NORNOR (XOR,NIMP) = LEQNOR (XOR,XOR) = LEQNOR (XOR,IMP) = NTRUNOR (XOR,NAND) = ANDNOR (XOR,TRU) = NTRUNOR (XOR,IF) = NTRUNOR (XOR,FIX) = NORNOR (XOR,LET) = NORNOR (XOR,NOR) = ANDNOR (IMP,LEQ) = NIMPNOR (IMP,OR) = NTRUNOR (IMP,DENY) = NTRUNOR (IMP,FLIP) = NIMPNOR (IMP,NIF) = NIMPNOR (IMP,NTRU) = NIMPNOR (IMP,AND) = NIMPNOR (IMP,NIMP) = NTRUNOR (IMP,XOR) = NTRUNOR (IMP,IMP) = NIMPNOR (IMP,NAND) = NTRUNOR (IMP,TRU) = NTRUNOR (IMP,IF) = NTRUNOR (IMP,FIX) = NTRUNOR (IMP,LET) = NIMPNOR (IMP,NOR) = NIMPNOR (NAND,LEQ) = NTRUNOR (NAND,OR) = NTRUNOR (NAND,DENY) = ANDNOR (NAND,FLIP) = ANDNOR (NAND,NIF) = ANDNOR (NAND,NTRU) = ANDNOR (NAND,AND) = NTRUNOR (NAND,NIMP) = ANDNOR (NAND,XOR) = ANDNOR (NAND,IMP) = NTRUNOR (NAND,NAND) = ANDNOR (NAND,TRU) = NTRUNOR (NAND,IF) = NTRUNOR (NAND,FIX) = NTRUNOR (NAND,LET) = NTRUNOR (NAND,NOR) = ANDNOR (TRU,LEQ) = NTRUNOR (TRU,OR) = NTRUNOR (TRU,DENY) = NTRUNOR (TRU,FLIP) = NTRUNOR (TRU,NIF) = NTRUNOR (TRU,NTRU) = NTRUNOR (TRU,AND) = NTRUNOR (TRU,NIMP) = NTRUNOR (TRU,XOR) = NTRUNOR (TRU,IMP) = NTRUNOR (TRU,NAND) = NTRUNOR (TRU,TRU) = NTRUNOR (TRU,IF) = NTRUNOR (TRU,FIX) = NTRUNOR (TRU,LET) = NTRUNOR (TRU,NOR) = NTRUNOR (IF,LEQ) = NIFNOR (IF,OR) = NTRUNOR (IF,DENY) = NIFNOR (IF,FLIP) = NTRUNOR (IF,NIF) = NTRUNOR (IF,NTRU) = NIFNOR (IF,AND) = NIFNOR (IF,NIMP) = NIFNOR (IF,XOR) = NTRUNOR (IF,IMP) = NTRUNOR (IF,NAND) = NTRUNOR (IF,TRU) = NTRUNOR (IF,IF) = NIFNOR (IF,FIX) = NIFNOR (IF,LET) = NTRUNOR (IF,NOR) = NIFNOR (FIX,LEQ) = NIFNOR (FIX,OR) = NORNOR (FIX,DENY) = NIFNOR (FIX,FLIP) = NTRUNOR (FIX,NIF) = NORNOR (FIX,NTRU) = FLIPNOR (FIX,AND) = FLIPNOR (FIX,NIMP) = FLIPNOR (FIX,XOR) = NORNOR (FIX,IMP) = NTRUNOR (FIX,NAND) = NTRUNOR (FIX,TRU) = NTRUNOR (FIX,IF) = NIFNOR (FIX,FIX) = FLIPNOR (FIX,LET) = NORNOR (FIX,NOR) = NIFNOR (LET,LEQ) = NIMPNOR (LET,OR) = NORNOR (LET,DENY) = NTRUNOR (LET,FLIP) = NIMPNOR (LET,NIF) = DENYNOR (LET,NTRU) = DENYNOR (LET,AND) = DENYNOR (LET,NIMP) = NORNOR (LET,XOR) = NORNOR (LET,IMP) = NIMPNOR (LET,NAND) = NTRUNOR (LET,TRU) = NTRUNOR (LET,IF) = NTRUNOR (LET,FIX) = NORNOR (LET,LET) = DENYNOR (LET,NOR) = NIMPNOR (NOR,LEQ) = XORNOR (NOR,OR) = NTRUNOR (NOR,DENY) = LETNOR (NOR,FLIP) = FIXNOR (NOR,NIF) = FIXNOR (NOR,NTRU) = ORNOR (NOR,AND) = XORNOR (NOR,NIMP) = LETNOR (NOR,XOR) = ANDNOR (NOR,IMP) = NIMPNOR (NOR,NAND) = ANDNOR (NOR,TRU) = NTRUNOR (NOR,IF) = NIFNOR (NOR,FIX) = NIFNOR (NOR,LET) = NIMPNOR (NOR,NOR) = OR
```