diff --git a/bin/columns.lisp b/bin/columns.lisp index c06cf708..fbbd04ee 100644 --- a/bin/columns.lisp +++ b/bin/columns.lisp @@ -1,57 +1,55 @@ (module bin) -(defcolumns - BINARY_STAMP - (ONE_LINE_INSTRUCTION :binary) - COUNTER - INST - ARGUMENT_1_HI - ARGUMENT_1_LO - ARGUMENT_2_HI - ARGUMENT_2_LO - RESULT_HI - RESULT_LO - (SMALL :binary) - (BITS :binary) - (BIT_B_4 :binary) - (NEG :binary) - LOW_4 - (BIT_1 :binary) - PIVOT - (BYTE_1 :byte) - (BYTE_2 :byte) - (BYTE_3 :byte) - (BYTE_4 :byte) - (BYTE_5 :byte) - (BYTE_6 :byte) - ACC_1 - ACC_2 - ACC_3 - ACC_4 - ACC_5 - ACC_6 - ;; decoded bytes: - AND_BYTE_HI - AND_BYTE_LO - OR_BYTE_HI - OR_BYTE_LO - XOR_BYTE_HI - XOR_BYTE_LO - NOT_BYTE_HI - NOT_BYTE_LO - (IS_DATA :binary)) +(defcolumns + STAMP + (ONE_LINE_INSTRUCTION :binary) + (MLI :binary) + (COUNTER :byte) + (INST :display :opcode) + ARGUMENT_1_HI + ARGUMENT_1_LO + ARGUMENT_2_HI + ARGUMENT_2_LO + RESULT_HI + RESULT_LO + (IS_AND :binary) + (IS_OR :binary) + (IS_XOR :binary) + (IS_NOT :binary) + (IS_BYTE :binary) + (IS_SIGNEXTEND :binary) + (SMALL :binary) + (BITS :binary) + (BIT_B_4 :binary) + (LOW_4 :byte) + (NEG :binary) + (BIT_1 :binary) + (PIVOT :byte) + (BYTE_1 :byte) + (BYTE_2 :byte) + (BYTE_3 :byte) + (BYTE_4 :byte) + (BYTE_5 :byte) + (BYTE_6 :byte) + ACC_1 + ACC_2 + ACC_3 + ACC_4 + ACC_5 + ACC_6 + ;; decoded bytes: + (XXX_BYTE_HI :byte) + (XXX_BYTE_LO :byte)) ;; aliases -(defalias - STAMP BINARY_STAMP - OLI ONE_LINE_INSTRUCTION - CT COUNTER - ARG_1_HI ARGUMENT_1_HI - ARG_1_LO ARGUMENT_1_LO - ARG_2_HI ARGUMENT_2_HI - ARG_2_LO ARGUMENT_2_LO - RES_HI RESULT_HI - RES_LO RESULT_LO) +(defalias + OLI ONE_LINE_INSTRUCTION + CT COUNTER + ARG_1_HI ARGUMENT_1_HI + ARG_1_LO ARGUMENT_1_LO + ARG_2_HI ARGUMENT_2_HI + ARG_2_LO ARGUMENT_2_LO + RES_HI RESULT_HI + RES_LO RESULT_LO) - \ No newline at end of file diff --git a/bin/constraints.lisp b/bin/constraints.lisp index b72c7400..ed657b7c 100644 --- a/bin/constraints.lisp +++ b/bin/constraints.lisp @@ -1,321 +1,234 @@ (module bin) -(defconst +(defconst ;; opcode values - SIGNEXTEND 11 - AND 22 - OR 23 - XOR 24 - NOT 25 - BYTE 26 + SIGNEXTEND 11 + AND 22 + OR 23 + XOR 24 + NOT 25 + BYTE 26 ;; constant values - LIMB_SIZE 16 - LIMB_SIZE_MINUS_ONE 15) + LLARGE 16 + LLARGEMO 15) -;;;;;;;;;;;;;;;;;;;;;;;;; -;; ;; -;; 2.1 heartbeat ;; -;; ;; -;;;;;;;;;;;;;;;;;;;;;;;;; -;; 2.1.1) -(defconstraint firstRow (:domain {0}) - (vanishes! STAMP)) - -;; 2.1.2) -(defconstraint stampIncrements () - (vanishes! (* (will-inc! STAMP 0) - (will-inc! STAMP 1)))) +(defpurefun (if-eq-else A B THEN ELSE) + (if-zero (- A B) + THEN + ELSE)) -;; 2.1.3) -(defconstraint zeroRow (:guard (is-zero STAMP)) - (begin (vanishes! OLI) - (vanishes! CT))) +;; 2.1 binary constraints +;; binary constraints +(defconstraint binary_constraints () + (begin (is-binary IS_AND) + (is-binary IS_OR) + (is-binary IS_XOR) + (is-binary IS_NOT) + (is-binary IS_BYTE) + (is-binary IS_SIGNEXTEND) + (is-binary SMALL) + (is-binary BITS) + (is-binary NEG) + (is-binary BIT_B_4) + (is-binary BIT_1))) + +;; 2.2 Shorthands +(defun (flag-sum) + (+ IS_AND IS_OR IS_XOR IS_NOT IS_BYTE IS_SIGNEXTEND)) + +(defun (weight-sum) + (+ (* IS_AND AND) + (* IS_OR OR) + (* IS_XOR XOR) + (* IS_NOT NOT) + (* IS_BYTE BYTE) + (* IS_SIGNEXTEND SIGNEXTEND))) + +;; 2.3 Instruction decoding +(defconstraint no-bin-no-flag () + (if-zero STAMP + (vanishes! (flag-sum)) + (eq! (flag-sum) 1))) -;; 2.1.4) -(defconstraint counterReset () - (if-not-zero (will-remain-constant! STAMP) - (vanishes! (shift CT 1)))) +(defconstraint inst-to-flag () + (eq! INST (weight-sum))) -;; 2.1.5) -(defconstraint heartbeat () - (if-not-zero STAMP - (if-zero OLI - ;; 2.1.5.a) - ;; If OLI == 0 - (if-eq-else CT LIMB_SIZE_MINUS_ONE - ;; 2.1.5.a).(ii) - ;; If CT == LIMB_SIZE_MINUS_ONE (i.e. 15) - (will-inc! STAMP 1) - ;; 2.1.5.a).(ii) - ;; If CT != LIMB_SIZE_MINUS_ONE (i.e. 15) - (begin (will-inc! CT 1) - (vanishes! (shift OLI 1)))) - ;; 2.1.5.a) - ;; If OLI == 1 - (will-inc! STAMP 1)))) -;; 2.1.6) -(defconstraint lastRow (:domain {-1} :guard STAMP) - (if-zero OLI - (eq! CT LIMB_SIZE_MINUS_ONE))) +;; 2.4 Heartbeat +(defconstraint first-row (:domain {0}) + (vanishes! STAMP)) -(defconstraint counter-constancies () - (begin - (counter-constancy CT PIVOT) - (counter-constancy CT BIT_B_4) - (counter-constancy CT LOW_4) - (counter-constancy CT NEG))) +(defconstraint stamp-increments () + (vanishes! (* (will-inc! STAMP 0) (will-inc! STAMP 1)))) -(defconstraint stamp-constancies () - (begin - (stamp-constancy STAMP ARG_1_HI) - (stamp-constancy STAMP ARG_1_LO) - (stamp-constancy STAMP ARG_2_HI) - (stamp-constancy STAMP ARG_2_LO) - (stamp-constancy STAMP RES_HI) - (stamp-constancy STAMP RES_LO) - (stamp-constancy STAMP INST))) +(defconstraint countereset () + (if-not-zero (will-remain-constant! STAMP) + (vanishes! (next CT)))) +(defconstraint oli-incrementation (:guard OLI) + (will-inc! STAMP 1)) -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; ;; -;; 2.2 byte decompositions ;; -;; ;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defconstraint mli-incrementation (:guard MLI) + (if-eq-else CT LLARGEMO (will-inc! STAMP 1) (will-inc! CT 1))) +(defconstraint last-row (:domain {-1}) + (if-eq MLI 1 (eq! CT LLARGEMO))) -;; byte decompositions +(defconstraint counter-constancies () + (begin (counter-constancy CT ARG_1_HI) + (counter-constancy CT ARG_1_LO) + (counter-constancy CT ARG_2_HI) + (counter-constancy CT ARG_2_LO) + (counter-constancy CT RES_HI) + (counter-constancy CT RES_LO) + (counter-constancy CT INST) + (counter-constancy CT PIVOT) + (counter-constancy CT BIT_B_4) + (counter-constancy CT LOW_4) + (counter-constancy CT NEG))) + +;; 2.6 byte decompositions (defconstraint byte_decompositions () - (begin - (byte-decomposition CT ACC_1 BYTE_1) - (byte-decomposition CT ACC_2 BYTE_2) - (byte-decomposition CT ACC_3 BYTE_3) - (byte-decomposition CT ACC_4 BYTE_4) - (byte-decomposition CT ACC_5 BYTE_5) - (byte-decomposition CT ACC_6 BYTE_6))) - -;; binary constraints -(defconstraint binary_constraints () - (begin - (is-binary OLI) - (is-binary SMALL) - (is-binary BITS) - (is-binary NEG) - (is-binary BIT_B_4) - (is-binary BIT_1))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; ;; -;; 2.3 target constraints ;; -;; ;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + (begin (byte-decomposition CT ACC_1 BYTE_1) + (byte-decomposition CT ACC_2 BYTE_2) + (byte-decomposition CT ACC_3 BYTE_3) + (byte-decomposition CT ACC_4 BYTE_4) + (byte-decomposition CT ACC_5 BYTE_5) + (byte-decomposition CT ACC_6 BYTE_6))) + +;; 2.7 target constraints (defconstraint target-constraints () - (if-eq CT LIMB_SIZE_MINUS_ONE - (begin - (= ACC_1 ARG_1_HI) - (= ACC_2 ARG_1_LO) - (= ACC_3 ARG_2_HI) - (= ACC_4 ARG_2_LO) - (= ACC_5 RES_HI) - (= ACC_6 RES_LO)))) + (if-eq CT LLARGEMO + (begin (eq! ACC_1 ARG_1_HI) + (eq! ACC_2 ARG_1_LO) + (eq! ACC_3 ARG_2_HI) + (eq! ACC_4 ARG_2_LO) + (eq! ACC_5 RES_HI) + (eq! ACC_6 RES_LO)))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; -;; 2.4 binary column constraints ;; +;; 2.8 binary column constraints ;; ;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defconstraint set-oli-mli () + (if-zero (+ IS_BYTE IS_SIGNEXTEND) + (vanishes! OLI) + (if-zero ARG_1_HI + (vanishes! OLI) + (eq! OLI 1)))) -;; 2.4.1 OLI constraints -(defconstraint oli-constraints () - (begin - (if-not-zero - (* (- INST BYTE) - (- INST SIGNEXTEND)) - (= OLI 0)) - (if-eq INST BYTE - (if-zero ARG_1_HI - (= OLI 0) - (= OLI 1))) - (if-eq INST SIGNEXTEND - (if-zero ARG_1_HI - (= OLI 0) - (= OLI 1))))) +(defconstraint oli-mli-exclusivity () + (eq! (+ OLI MLI) (flag-sum))) -;; 2.4.2 BITS and related columns +;; 2.8.2 BITS and related columns (defconstraint bits-and-related () - (if-eq CT LIMB_SIZE_MINUS_ONE - (begin (= BYTE_2 - (+ (* 128 (shift BITS -7)) - (* 64 (shift BITS -6)) - (* 32 (shift BITS -5)) - (* 16 (shift BITS -4)) - (* 8 (shift BITS -3)) - (* 4 (shift BITS -2)) - (* 2 (shift BITS -1)) - BITS)) - (= LOW_4 - (+ (* 8 (shift BITS -3)) - (* 4 (shift BITS -2)) - (* 2 (shift BITS -1)) - BITS)) - (= BIT_B_4 - (shift BITS -4)) - (= PIVOT - (+ (* 128 (shift BITS -15)) - (* 64 (shift BITS -14)) - (* 32 (shift BITS -13)) - (* 16 (shift BITS -12)) - (* 8 (shift BITS -11)) - (* 4 (shift BITS -10)) - (* 2 (shift BITS -9)) - (shift BITS -8))) - (= NEG (shift BITS -15))))) - -;; 2.4.3 [[1]] constraints + (if-eq CT LLARGEMO + (begin (eq! PIVOT + (+ (* 128 (shift BITS -15)) + (* 64 (shift BITS -14)) + (* 32 (shift BITS -13)) + (* 16 (shift BITS -12)) + (* 8 (shift BITS -11)) + (* 4 (shift BITS -10)) + (* 2 (shift BITS -9)) + (shift BITS -8))) + (eq! BYTE_2 + (+ (* 128 (shift BITS -7)) + (* 64 (shift BITS -6)) + (* 32 (shift BITS -5)) + (* 16 (shift BITS -4)) + (* 8 (shift BITS -3)) + (* 4 (shift BITS -2)) + (* 2 (shift BITS -1)) + BITS)) + (eq! LOW_4 + (+ (* 8 (shift BITS -3)) + (* 4 (shift BITS -2)) + (* 2 (shift BITS -1)) + BITS)) + (eq! BIT_B_4 (shift BITS -4)) + (eq! NEG (shift BITS -15))))) + +;; 2.8.3 [[1]] constraints (defconstraint bit_1 () - (begin - (if-eq INST BYTE - (plateau-constraint CT BIT_1 LOW_4)) - (if-eq INST SIGNEXTEND - (plateau-constraint CT BIT_1 (- LIMB_SIZE_MINUS_ONE LOW_4))))) + (begin (if-eq IS_BYTE 1 (plateau-constraint CT BIT_1 LOW_4)) + (if-eq IS_SIGNEXTEND 1 + (plateau-constraint CT BIT_1 (- LLARGEMO LOW_4))))) -;; 2.4.4 SMALL constraints +;; 2.8.4 SMALL constraints (defconstraint small () - (if-eq CT LIMB_SIZE_MINUS_ONE + (if-eq CT LLARGEMO (if-zero ARG_1_HI - (if-eq-else - ARG_1_LO - (+ - (* 16 (shift BITS -4)) - (* 8 (shift BITS -3)) - (* 4 (shift BITS -2)) - (* 2 (shift BITS -1)) - BITS) - (= SMALL 1) - (vanishes! SMALL))))) - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; ;; -;; 2.3 pivot constraints ;; -;; ;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun (pivot_case_byte) - (begin (if-zero LOW_4 - ;; LOW_4 == 0 - (if-zero CT - ;; CT == 0 - (if-zero BIT_B_4 - ;; b4 == 0 - (= PIVOT BYTE_3) - ;; b4 == 1 - (= PIVOT BYTE_4)))) - (if-not-zero LOW_4 - ;; LOW_4 != 0 - (if-zero (shift BIT_1 -1) - ;; [[1]][i-1] == 0 - (if-not-zero BIT_1 - ;; [[1]][i] == 1 - (if-zero BIT_B_4 - ;; b4 == 0 - (= PIVOT BYTE_3) - ;; b4 == 1 - (= PIVOT BYTE_4))))))) - -(defun (pivot_case_signextend) - (begin - (if-eq LOW_4 LIMB_SIZE_MINUS_ONE - ;; LOW_4 == 15 - (if-zero CT - (if-zero BIT_B_4 - ;; b4 == 0 - (= PIVOT BYTE_4) - ;; b4 == 1 - (= PIVOT BYTE_3)))) - (if-not-zero (- LOW_4 LIMB_SIZE_MINUS_ONE) - ;; LOW_4 != 15 - (if-zero (shift BIT_1 -1) - ;; [[1]][i-1] == 0 - (if-not-zero BIT_1 - ;; [[1]][i] == 1 + (if-eq-else ARG_1_LO (+ (* 16 (shift BITS -4)) + (* 8 (shift BITS -3)) + (* 4 (shift BITS -2)) + (* 2 (shift BITS -1)) + BITS) + (eq! SMALL 1) + (vanishes! SMALL))))) + +;; 2.9 pivot constraints +(defconstraint pivot (:guard MLI) + (begin (if-not-zero IS_BYTE + (if-zero LOW_4 + (if-zero CT (if-zero BIT_B_4 - ;; b4 == 0 - (= PIVOT BYTE_4) - ;; b4 == 1 - (= PIVOT BYTE_3))))))) - -(defconstraint pivot () - (if-not-zero STAMP - ;; BINARY_STAMP != 0 - (if-zero OLI - ;; OLI == 0 - (begin (if-eq INST BYTE (pivot_case_byte)) - (if-eq INST SIGNEXTEND (pivot_case_signextend)))))) - + (eq! PIVOT BYTE_3) + (eq! PIVOT BYTE_4))) + (if-zero (+ (prev BIT_1) (- 1 BIT_1)) + (if-zero BIT_B_4 + (eq! PIVOT BYTE_3) + (eq! PIVOT BYTE_4))))) + (if-not-zero IS_SIGNEXTEND + (if-eq-else LOW_4 LLARGEMO + (if-zero CT + (if-zero BIT_B_4 + (eq! PIVOT BYTE_4) + (eq! PIVOT BYTE_3))) + (if-zero (+ (prev BIT_1) (- 1 BIT_1)) + (if-zero BIT_B_4 + (eq! PIVOT BYTE_4) + (eq! PIVOT BYTE_3))))))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; -;; 2.3 result constraints ;; +;; 2.10 result constraints ;; ;; ;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defconstraint is-byte-result (:guard IS_BYTE) + (if-eq-else OLI 1 + (begin (vanishes! RES_HI) + (vanishes! RES_LO)) + (begin (vanishes! RES_HI) + (eq! RES_LO (* SMALL PIVOT))))) + +(defconstraint is-signextend-result (:guard IS_SIGNEXTEND) + (if-eq-else OLI 1 + (begin (eq! RES_HI ARG_2_HI) + (eq! RES_LO ARG_2_LO)) + (if-zero SMALL + ;; SMALL == 0 + (begin (eq! RES_HI ARG_2_HI) + (eq! RES_LO ARG_2_LO)) + ;; SMALL == 1 + (begin (if-zero BIT_B_4 + ;; b4 == 0 + (begin (eq! BYTE_5 (* NEG 255)) + (if-zero BIT_1 + ;; [[1]] == 0 + (eq! BYTE_6 (* NEG 255)) + ;; [[1]] == 1 + (eq! BYTE_6 BYTE_4))) + ;; b4 == 1 + (begin (if-zero BIT_1 + ;; [[1]] == 0 + (eq! BYTE_5 (* NEG 255)) + ;; [[1]] == 1 + (eq! BYTE_5 BYTE_3)) + (eq! RES_LO ARG_2_LO))))))) + +(defconstraint result-via-lookup (:guard (+ IS_AND IS_OR IS_XOR IS_NOT)) + (begin (eq! BYTE_5 XXX_BYTE_HI) + (eq! BYTE_6 XXX_BYTE_LO))) -(defun (result_signextend) - (if-zero SMALL - ;; SMALL == 0 - (begin - (= RES_HI ARG_2_HI) - (= RES_LO ARG_2_LO)) - ;; SMALL == 1 - (begin - (if-zero BIT_B_4 - ;; b4 == 0 - (begin - (= BYTE_5 (* NEG 255)) - (if-zero BIT_1 - ;; [[1]] == 0 - (= BYTE_6 (* NEG 255)) - ;; [[1]] == 1 - (= BYTE_6 BYTE_4))) - ;; b4 == 1 - (begin - (if-zero BIT_1 - ;; [[1]] == 0 - (= BYTE_5 (* NEG 255)) - ;; [[1]] == 1 - (= BYTE_5 BYTE_3)) - (= RES_LO ARG_2_LO)))))) -(defconstraint result () - (if-not-zero STAMP - (if-not-zero OLI - ;; OLI == 1 - (begin (if-eq INST BYTE - (begin (vanishes! RES_HI) - (vanishes! RES_LO))) - (if-eq INST SIGNEXTEND - (begin (= RES_HI ARG_2_HI) - (= RES_LO ARG_2_LO)))) - ;; OLI == 0 - (begin (if-eq INST AND - (begin (= BYTE_5 AND_BYTE_HI) - (= BYTE_6 AND_BYTE_LO))) - (if-eq INST OR - (begin (= BYTE_5 OR_BYTE_HI) - (= BYTE_6 OR_BYTE_LO))) - (if-eq INST XOR - (begin (= BYTE_5 XOR_BYTE_HI) - (= BYTE_6 XOR_BYTE_LO))) - (if-eq INST NOT - (begin (= BYTE_5 NOT_BYTE_HI) - (= BYTE_6 NOT_BYTE_LO))) - (if-eq INST BYTE - (begin (vanishes! RES_HI) - (= RES_LO (* SMALL PIVOT)))) - (if-eq INST SIGNEXTEND - (result_signextend)))))) - -;; IS_DATA -(defconstraint is_data () - (if-zero STAMP - (vanishes! IS_DATA) - (eq! IS_DATA 1))) diff --git a/lookup_tables/binRT/columns.lisp b/lookup_tables/binRT/columns.lisp index 11a25c0e..6a10d663 100644 --- a/lookup_tables/binRT/columns.lisp +++ b/lookup_tables/binRT/columns.lisp @@ -1,11 +1,9 @@ (module binRT) -(defcolumns - BYTE_ARG_1 - BYTE_ARG_2 - AND_BYTE - OR_BYTE - XOR_BYTE - NOT_BYTE - IS_IN_RT ; column populated with 1's while in reference table -) +(defcolumns + (INST :byte :display :opcode) + (RESULT_BYTE :byte) + (INPUT_BYTE_1 :byte) + (INPUT_BYTE_2 :byte)) + + diff --git a/lookup_tables/lookups/bin_into_binRT.lisp b/lookup_tables/lookups/bin_into_binRT.lisp index 271d46e9..580091a0 100644 --- a/lookup_tables/lookups/bin_into_binRT.lisp +++ b/lookup_tables/lookups/bin_into_binRT.lisp @@ -1,45 +1,38 @@ -(deflookup bin-lookup-table-high - ;reference columns - ( - binRT.BYTE_ARG_1 - binRT.BYTE_ARG_2 - binRT.AND_BYTE - binRT.OR_BYTE - binRT.XOR_BYTE - binRT.NOT_BYTE - binRT.IS_IN_RT - ) - ;source columns - ( - bin.BYTE_1 - bin.BYTE_3 - bin.AND_BYTE_HI - bin.OR_BYTE_HI - bin.XOR_BYTE_HI - bin.NOT_BYTE_HI - bin.IS_DATA - ) -) +(defpurefun (selector-bin-to-binRT) + (+ bin.IS_AND bin.IS_OR bin.IS_XOR bin.IS_NOT)) + +(deflookup + bin-lookup-table-high + ;reference columns + ( + binRT.INST + binRT.RESULT_BYTE + binRT.INPUT_BYTE_1 + binRT.INPUT_BYTE_2 + ) + ;source columns + ( + (* bin.INST (selector-bin-to-binRT)) + (* bin.XXX_BYTE_HI (selector-bin-to-binRT)) + (* bin.BYTE_1 (selector-bin-to-binRT)) + (* bin.BYTE_3 (selector-bin-to-binRT)) + )) + +(deflookup + bin-lookup-table-low + ;reference columns + ( + binRT.INST + binRT.RESULT_BYTE + binRT.INPUT_BYTE_1 + binRT.INPUT_BYTE_2 + ) + ;source columns + ( + (* bin.INST (selector-bin-to-binRT)) + (* bin.XXX_BYTE_LO (selector-bin-to-binRT)) + (* bin.BYTE_2 (selector-bin-to-binRT)) + (* bin.BYTE_4 (selector-bin-to-binRT)) + )) + -(deflookup bin-lookup-table-low - ;reference columns - ( - binRT.BYTE_ARG_1 - binRT.BYTE_ARG_2 - binRT.AND_BYTE - binRT.OR_BYTE - binRT.XOR_BYTE - binRT.NOT_BYTE - binRT.IS_IN_RT - ) - ;source columns - ( - bin.BYTE_2 - bin.BYTE_4 - bin.AND_BYTE_LO - bin.OR_BYTE_LO - bin.XOR_BYTE_LO - bin.NOT_BYTE_LO - bin.IS_DATA - ) -) \ No newline at end of file